deepwork 0.2.0__py3-none-any.whl → 0.3.1__py3-none-any.whl

deepwork/cli/install.py

@@ -73,9 +73,9 @@ def _inject_deepwork_jobs(jobs_dir: Path, project_path: Path) -> None:
     _inject_standard_job("deepwork_jobs", jobs_dir, project_path)
 
 
-def _inject_deepwork_policy(jobs_dir: Path, project_path: Path) -> None:
+def _inject_deepwork_rules(jobs_dir: Path, project_path: Path) -> None:
     """
-    Inject the deepwork_policy job definition into the project.
+    Inject the deepwork_rules job definition into the project.
 
     Args:
         jobs_dir: Path to .deepwork/jobs directory
@@ -84,7 +84,7 @@ def _inject_deepwork_policy(jobs_dir: Path, project_path: Path) -> None:
     Raises:
         InstallError: If injection fails
     """
-    _inject_standard_job("deepwork_policy", jobs_dir, project_path)
+    _inject_standard_job("deepwork_rules", jobs_dir, project_path)
 
 
 def _create_deepwork_gitignore(deepwork_dir: Path) -> None:
@@ -98,7 +98,7 @@ def _create_deepwork_gitignore(deepwork_dir: Path) -> None:
     """
     gitignore_path = deepwork_dir / ".gitignore"
     gitignore_content = """# DeepWork temporary files
-# These files are used for policy evaluation during sessions
+# These files are used for rules evaluation during sessions
 .last_work_tree
 """
 
@@ -113,44 +113,83 @@ def _create_deepwork_gitignore(deepwork_dir: Path) -> None:
         gitignore_path.write_text(gitignore_content)
 
 
-def _create_default_policy_file(project_path: Path) -> bool:
+def _create_rules_directory(project_path: Path) -> bool:
     """
-    Create a default policy file template in the project root.
+    Create the v2 rules directory structure with example templates.
 
-    Only creates the file if it doesn't already exist.
+    Creates .deepwork/rules/ with example rule files that users can customize.
+    Only creates the directory if it doesn't already exist.
 
     Args:
         project_path: Path to the project root
 
     Returns:
-        True if the file was created, False if it already existed
+        True if the directory was created, False if it already existed
     """
-    policy_file = project_path / ".deepwork.policy.yml"
+    rules_dir = project_path / ".deepwork" / "rules"
 
-    if policy_file.exists():
+    if rules_dir.exists():
         return False
 
-    # Copy the template from the templates directory
-    template_path = Path(__file__).parent.parent / "templates" / "default_policy.yml"
+    # Create the rules directory
+    ensure_dir(rules_dir)
 
-    if template_path.exists():
-        shutil.copy(template_path, policy_file)
-    else:
-        # Fallback: create a minimal template inline
-        policy_file.write_text(
-            """# DeepWork Policy Configuration
-#
-# Policies are automated guardrails that trigger when specific files change.
-# Use /deepwork_policy.define to create new policies interactively.
-#
-# Format:
-#   - name: "Policy name"
-#     trigger: "glob/pattern/**/*"
-#     safety: "optional/pattern/**/*"
-#     instructions: |
-#       Instructions for the AI agent...
+    # Copy example rule templates from the deepwork_rules standard job
+    example_rules_dir = Path(__file__).parent.parent / "standard_jobs" / "deepwork_rules" / "rules"
+
+    if example_rules_dir.exists():
+        # Copy all .example files
+        for example_file in example_rules_dir.glob("*.md.example"):
+            dest_file = rules_dir / example_file.name
+            shutil.copy(example_file, dest_file)
+
+    # Create a README file explaining the rules system
+    readme_content = """# DeepWork Rules
+
+Rules are automated guardrails that trigger when specific files change during
+AI agent sessions. They help ensure documentation stays current, security reviews
+happen, and team guidelines are followed.
+
+## Getting Started
+
+1. Copy an example file and rename it (remove the `.example` suffix):
+   ```
+   cp readme-documentation.md.example readme-documentation.md
+   ```
+
+2. Edit the file to match your project's patterns
+
+3. The rule will automatically trigger when matching files change
+
+## Rule Format
+
+Rules use YAML frontmatter in markdown files:
+
+```markdown
+---
+name: Rule Name
+trigger: "pattern/**/*"
+safety: "optional/pattern"
+---
+Instructions in markdown here.
+```
+
+## Detection Modes
+
+- **trigger/safety**: Fire when trigger matches, unless safety also matches
+- **set**: Bidirectional file correspondence (e.g., source + test)
+- **pair**: Directional correspondence (e.g., API code -> docs)
+
+## Documentation
+
+See `doc/rules_syntax.md` in the DeepWork repository for full syntax documentation.
+
+## Creating Rules Interactively
+
+Use `/deepwork_rules.define` to create new rules with guidance.
 """
-        )
+    readme_path = rules_dir / "README.md"
+    readme_path.write_text(readme_content)
 
     return True
 
@@ -216,8 +255,10 @@ def _install_deepwork(platform_name: str | None, project_path: Path) -> None:
         )
     console.print("  [green]✓[/green] Git repository found")
 
-    # Step 2: Detect or validate platform
+    # Step 2: Detect or validate platform(s)
     detector = PlatformDetector(project_path)
+    platforms_to_add: list[str] = []
+    detected_adapters: list[AgentAdapter] = []
 
     if platform_name:
         # User specified platform - check if it's available
@@ -234,34 +275,33 @@ def _install_deepwork(platform_name: str | None, project_path: Path) -> None:
             )
 
         console.print(f"  [green]✓[/green] {adapter.display_name} detected")
-        platform_to_add = adapter.name
+        platforms_to_add = [adapter.name]
+        detected_adapters = [adapter]
     else:
-        # Auto-detect platform
-        console.print("[yellow]→[/yellow] Auto-detecting AI platform...")
+        # Auto-detect all available platforms
+        console.print("[yellow]→[/yellow] Auto-detecting AI platforms...")
         available_adapters = detector.detect_all_platforms()
 
         if not available_adapters:
-            supported = ", ".join(
-                f"{AgentAdapter.get(name).display_name} ({AgentAdapter.get(name).config_dir}/)"
-                for name in AgentAdapter.list_names()
-            )
-            raise InstallError(
-                f"No AI platform detected.\n"
-                f"DeepWork supports: {supported}.\n"
-                "Please set up one of these platforms first, or use --platform to specify."
-            )
-
-        if len(available_adapters) > 1:
-            # Multiple platforms - ask user to specify
-            platform_names = ", ".join(a.display_name for a in available_adapters)
-            raise InstallError(
-                f"Multiple AI platforms detected: {platform_names}\n"
-                "Please specify which platform to use with --platform option."
-            )
-
-        adapter = available_adapters[0]
-        console.print(f"  [green]✓[/green] {adapter.display_name} detected")
-        platform_to_add = adapter.name
+            # No platforms detected - default to Claude Code
+            console.print("  [dim]•[/dim] No AI platform detected, defaulting to Claude Code")
+
+            # Create .claude directory
+            claude_dir = project_path / ".claude"
+            ensure_dir(claude_dir)
+            console.print(f"  [green]✓[/green] Created {claude_dir.relative_to(project_path)}/")
+
+            # Get Claude adapter
+            claude_adapter_class = AgentAdapter.get("claude")
+            claude_adapter = claude_adapter_class(project_root=project_path)
+            platforms_to_add = [claude_adapter.name]
+            detected_adapters = [claude_adapter]
+        else:
+            # Add all detected platforms
+            for adapter in available_adapters:
+                console.print(f"  [green]✓[/green] {adapter.display_name} detected")
+                platforms_to_add.append(adapter.name)
+            detected_adapters = available_adapters
 
     # Step 3: Create .deepwork/ directory structure
     console.print("[yellow]→[/yellow] Creating DeepWork directory structure...")
@@ -274,17 +314,17 @@ def _install_deepwork(platform_name: str | None, project_path: Path) -> None:
     # Step 3b: Inject standard jobs (core job definitions)
     console.print("[yellow]→[/yellow] Installing core job definitions...")
     _inject_deepwork_jobs(jobs_dir, project_path)
-    _inject_deepwork_policy(jobs_dir, project_path)
+    _inject_deepwork_rules(jobs_dir, project_path)
 
     # Step 3c: Create .gitignore for temporary files
     _create_deepwork_gitignore(deepwork_dir)
     console.print("  [green]✓[/green] Created .deepwork/.gitignore")
 
-    # Step 3d: Create default policy file template
-    if _create_default_policy_file(project_path):
-        console.print("  [green]✓[/green] Created .deepwork.policy.yml template")
+    # Step 3d: Create rules directory with v2 templates
+    if _create_rules_directory(project_path):
+        console.print("  [green]✓[/green] Created .deepwork/rules/ with example templates")
     else:
-        console.print("  [dim]•[/dim] .deepwork.policy.yml already exists")
+        console.print("  [dim]•[/dim] .deepwork/rules/ already exists")
 
     # Step 4: Load or create config.yml
     console.print("[yellow]→[/yellow] Updating configuration...")
@@ -304,32 +344,37 @@ def _install_deepwork(platform_name: str | None, project_path: Path) -> None:
     if "platforms" not in config_data:
         config_data["platforms"] = []
 
-    # Add platform if not already present
-    if platform_to_add not in config_data["platforms"]:
-        config_data["platforms"].append(platform_to_add)
-        console.print(f"  [green]✓[/green] Added {adapter.display_name} to platforms")
-    else:
-        console.print(f"  [dim]•[/dim] {adapter.display_name} already configured")
+    # Add each platform if not already present
+    added_platforms: list[str] = []
+    for i, platform in enumerate(platforms_to_add):
+        adapter = detected_adapters[i]
+        if platform not in config_data["platforms"]:
+            config_data["platforms"].append(platform)
+            added_platforms.append(adapter.display_name)
+            console.print(f"  [green]✓[/green] Added {adapter.display_name} to platforms")
+        else:
+            console.print(f"  [dim]•[/dim] {adapter.display_name} already configured")
 
     save_yaml(config_file, config_data)
     console.print(f"  [green]✓[/green] Updated {config_file.relative_to(project_path)}")
 
-    # Step 5: Run sync to generate commands
+    # Step 5: Run sync to generate skills
     console.print()
-    console.print("[yellow]→[/yellow] Running sync to generate commands...")
+    console.print("[yellow]→[/yellow] Running sync to generate skills...")
     console.print()
 
-    from deepwork.cli.sync import sync_commands
+    from deepwork.cli.sync import sync_skills
 
     try:
-        sync_commands(project_path)
+        sync_skills(project_path)
     except Exception as e:
-        raise InstallError(f"Failed to sync commands: {e}") from e
+        raise InstallError(f"Failed to sync skills: {e}") from e
 
     # Success message
     console.print()
+    platform_names = ", ".join(a.display_name for a in detected_adapters)
     console.print(
-        f"[bold green]✓ DeepWork installed successfully for {adapter.display_name}![/bold green]"
+        f"[bold green]✓ DeepWork installed successfully for {platform_names}![/bold green]"
     )
     console.print()
     console.print("[bold]Next steps:[/bold]")

deepwork/cli/sync.py

@@ -7,7 +7,7 @@ from rich.console import Console
 from rich.table import Table
 
 from deepwork.core.adapters import AgentAdapter
-from deepwork.core.generator import CommandGenerator
+from deepwork.core.generator import SkillGenerator
 from deepwork.core.hooks_syncer import collect_job_hooks, sync_hooks_to_platform
 from deepwork.core.parser import parse_job_definition
 from deepwork.utils.fs import ensure_dir
@@ -31,13 +31,13 @@ class SyncError(Exception):
 )
 def sync(path: Path) -> None:
     """
-    Sync DeepWork commands to all configured platforms.
+    Sync DeepWork skills to all configured platforms.
 
-    Regenerates all slash-commands for job steps and core commands based on
+    Regenerates all skills for job steps and core skills based on
     the current job definitions in .deepwork/jobs/.
     """
     try:
-        sync_commands(path)
+        sync_skills(path)
     except SyncError as e:
         console.print(f"[red]Error:[/red] {e}")
         raise click.Abort() from e
@@ -46,9 +46,9 @@ def sync(path: Path) -> None:
         raise
 
 
-def sync_commands(project_path: Path) -> None:
+def sync_skills(project_path: Path) -> None:
     """
-    Sync commands to all configured platforms.
+    Sync skills to all configured platforms.
 
     Args:
         project_path: Path to project directory
@@ -78,7 +78,7 @@ def sync_commands(project_path: Path) -> None:
             "Run 'deepwork install --platform <platform>' to add a platform."
         )
 
-    console.print("[bold cyan]Syncing DeepWork Commands[/bold cyan]\n")
+    console.print("[bold cyan]Syncing DeepWork Skills[/bold cyan]\n")
 
     # Discover jobs
     jobs_dir = deepwork_dir / "jobs"
@@ -115,8 +115,8 @@ def sync_commands(project_path: Path) -> None:
         console.print(f"[yellow]→[/yellow] Found {len(job_hooks_list)} job(s) with hooks")
 
     # Sync each platform
-    generator = CommandGenerator()
-    stats = {"platforms": 0, "commands": 0, "hooks": 0}
+    generator = SkillGenerator()
+    stats = {"platforms": 0, "skills": 0, "hooks": 0}
     synced_adapters: list[AgentAdapter] = []
 
     for platform_name in platforms:
@@ -130,19 +130,19 @@ def sync_commands(project_path: Path) -> None:
         console.print(f"\n[yellow]→[/yellow] Syncing to {adapter.display_name}...")
 
         platform_dir = project_path / adapter.config_dir
-        commands_dir = platform_dir / adapter.commands_dir
+        skills_dir = platform_dir / adapter.skills_dir
 
-        # Create commands directory
-        ensure_dir(commands_dir)
+        # Create skills directory
+        ensure_dir(skills_dir)
 
-        # Generate commands for all jobs
+        # Generate skills for all jobs
         if jobs:
-            console.print("  [dim]•[/dim] Generating commands...")
+            console.print("  [dim]•[/dim] Generating skills...")
             for job in jobs:
                 try:
-                    job_paths = generator.generate_all_commands(job, adapter, platform_dir)
-                    stats["commands"] += len(job_paths)
-                    console.print(f"    [green]✓[/green] {job.name} ({len(job_paths)} commands)")
+                    job_paths = generator.generate_all_skills(job, adapter, platform_dir)
+                    stats["skills"] += len(job_paths)
+                    console.print(f"    [green]✓[/green] {job.name} ({len(job_paths)} skills)")
                 except Exception as e:
                     console.print(f"    [red]✗[/red] Failed for {job.name}: {e}")
 
@@ -170,7 +170,7 @@ def sync_commands(project_path: Path) -> None:
     table.add_column("Count", style="green")
 
     table.add_row("Platforms synced", str(stats["platforms"]))
-    table.add_row("Total commands", str(stats["commands"]))
+    table.add_row("Total skills", str(stats["skills"]))
     if stats["hooks"] > 0:
         table.add_row("Hooks synced", str(stats["hooks"]))
 
@@ -178,8 +178,8 @@ def sync_commands(project_path: Path) -> None:
     console.print()
 
     # Show reload instructions for each synced platform
-    if synced_adapters and stats["commands"] > 0:
-        console.print("[bold]To use the new commands:[/bold]")
+    if synced_adapters and stats["skills"] > 0:
+        console.print("[bold]To use the new skills:[/bold]")
         for adapter in synced_adapters:
             console.print(f"  [cyan]{adapter.display_name}:[/cyan] {adapter.reload_instructions}")
         console.print()

deepwork/core/adapters.py

@@ -15,10 +15,10 @@ class AdapterError(Exception):
     pass
 
 
-class CommandLifecycleHook(str, Enum):
-    """Generic command lifecycle hook events supported by DeepWork.
+class SkillLifecycleHook(str, Enum):
+    """Generic skill lifecycle hook events supported by DeepWork.
 
-    These represent hook points in the AI agent's command execution lifecycle.
+    These represent hook points in the AI agent's skill execution lifecycle.
     Each adapter maps these generic names to platform-specific event names.
     The enum values are the generic names used in job.yml files.
     """
@@ -36,8 +36,8 @@ class CommandLifecycleHook(str, Enum):
     BEFORE_PROMPT = "before_prompt"
 
 
-# List of all supported command lifecycle hooks
-COMMAND_LIFECYCLE_HOOKS_SUPPORTED: list[CommandLifecycleHook] = list(CommandLifecycleHook)
+# List of all supported skill lifecycle hooks
+SKILL_LIFECYCLE_HOOKS_SUPPORTED: list[SkillLifecycleHook] = list(SkillLifecycleHook)
 
 
 class AgentAdapter(ABC):
@@ -54,18 +54,17 @@ class AgentAdapter(ABC):
     name: ClassVar[str]
     display_name: ClassVar[str]
     config_dir: ClassVar[str]
-    commands_dir: ClassVar[str] = "commands"
-    command_template: ClassVar[str] = "command-job-step.md.jinja"
+    skills_dir: ClassVar[str] = "skills"
+    skill_template: ClassVar[str] = "skill-job-step.md.jinja"
+    meta_skill_template: ClassVar[str] = "skill-job-meta.md.jinja"
 
-    # Instructions for reloading commands after sync (shown to users)
+    # Instructions for reloading skills after sync (shown to users)
     # Subclasses should override with platform-specific instructions.
-    reload_instructions: ClassVar[str] = (
-        "Restart your AI assistant session to use the new commands."
-    )
+    reload_instructions: ClassVar[str] = "Restart your AI assistant session to use the new skills."
 
-    # Mapping from generic CommandLifecycleHook to platform-specific event names.
+    # Mapping from generic SkillLifecycleHook to platform-specific event names.
     # Subclasses should override this to provide platform-specific mappings.
-    hook_name_mapping: ClassVar[dict[CommandLifecycleHook, str]] = {}
+    hook_name_mapping: ClassVar[dict[SkillLifecycleHook, str]] = {}
 
     def __init__(self, project_root: Path | str | None = None):
         """
@@ -135,15 +134,15 @@ class AgentAdapter(ABC):
         """
         return templates_root / self.name
 
-    def get_commands_dir(self, project_root: Path | None = None) -> Path:
+    def get_skills_dir(self, project_root: Path | None = None) -> Path:
         """
-        Get the commands directory path.
+        Get the skills directory path.
 
         Args:
             project_root: Project root (uses instance's project_root if not provided)
 
         Returns:
-            Path to commands directory
+            Path to skills directory
 
         Raises:
             AdapterError: If no project root specified
@@ -151,22 +150,39 @@ class AgentAdapter(ABC):
         root = project_root or self.project_root
         if not root:
             raise AdapterError("No project root specified")
-        return root / self.config_dir / self.commands_dir
+        return root / self.config_dir / self.skills_dir
+
+    def get_meta_skill_filename(self, job_name: str) -> str:
+        """
+        Get the filename for a job's meta-skill.
+
+        The meta-skill is the primary user interface for a job.
+        Can be overridden for different file formats.
+
+        Args:
+            job_name: Name of the job
+
+        Returns:
+            Meta-skill filename (e.g., "job_name/SKILL.md" for Claude)
+        """
+        return f"{job_name}/SKILL.md"
 
-    def get_command_filename(self, job_name: str, step_id: str) -> str:
+    def get_step_skill_filename(self, job_name: str, step_id: str, exposed: bool = False) -> str:
         """
-        Get the filename for a command.
+        Get the filename for a step skill.
 
-        Can be overridden for different file formats (e.g., TOML for Gemini).
+        All step skills use the same filename format. The exposed parameter
+        is used for template context (user-invocable frontmatter setting).
 
         Args:
             job_name: Name of the job
             step_id: ID of the step
+            exposed: If True, skill is user-invocable (for template context). Default: False.
 
         Returns:
-            Command filename (e.g., "job_name.step_id.md")
+            Skill filename (e.g., "job_name.step_id/SKILL.md" for Claude)
         """
-        return f"{job_name}.{step_id}.md"
+        return f"{job_name}.{step_id}/SKILL.md"
 
     def detect(self, project_root: Path | None = None) -> bool:
         """
@@ -184,24 +200,24 @@ class AgentAdapter(ABC):
         config_path = root / self.config_dir
         return config_path.exists() and config_path.is_dir()
 
-    def get_platform_hook_name(self, hook: CommandLifecycleHook) -> str | None:
+    def get_platform_hook_name(self, hook: SkillLifecycleHook) -> str | None:
         """
         Get the platform-specific event name for a generic hook.
 
         Args:
-            hook: Generic CommandLifecycleHook
+            hook: Generic SkillLifecycleHook
 
         Returns:
             Platform-specific event name, or None if not supported
         """
         return self.hook_name_mapping.get(hook)
 
-    def supports_hook(self, hook: CommandLifecycleHook) -> bool:
+    def supports_hook(self, hook: SkillLifecycleHook) -> bool:
         """
         Check if this adapter supports a specific hook.
 
         Args:
-            hook: Generic CommandLifecycleHook
+            hook: Generic SkillLifecycleHook
 
         Returns:
             True if the hook is supported
@@ -241,13 +257,15 @@ def _hook_already_present(hooks: list[dict[str, Any]], script_path: str) -> bool
 # =============================================================================
 #
 # Each adapter must define hook_name_mapping to indicate which hooks it supports.
-# Use an empty dict {} for platforms that don't support command-level hooks.
+# Use an empty dict {} for platforms that don't support skill-level hooks.
 #
 # Hook support reviewed:
-# - Claude Code: Full support (Stop, PreToolUse, UserPromptSubmit) - 2025-01
-# - Gemini CLI: No command-level hooks (reviewed 2026-01-12)
-#   Gemini's hooks are global/project-level in settings.json, not per-command.
-#   TOML command files only support 'prompt' and 'description' fields.
+# - Claude Code: Full support (Stop, PreToolUse, UserPromptSubmit) - reviewed 2026-01-16
+#   All three skill lifecycle hooks are supported in markdown frontmatter.
+#   See: doc/platforms/claude/hooks_system.md
+# - Gemini CLI: No skill-level hooks (reviewed 2026-01-12)
+#   Gemini's hooks are global/project-level in settings.json, not per-skill.
+#   TOML skill files only support 'prompt' and 'description' fields.
 #   See: doc/platforms/gemini/hooks_system.md
 # =============================================================================
 
@@ -266,10 +284,10 @@ class ClaudeAdapter(AgentAdapter):
     )
 
     # Claude Code uses PascalCase event names
-    hook_name_mapping: ClassVar[dict[CommandLifecycleHook, str]] = {
-        CommandLifecycleHook.AFTER_AGENT: "Stop",
-        CommandLifecycleHook.BEFORE_TOOL: "PreToolUse",
-        CommandLifecycleHook.BEFORE_PROMPT: "UserPromptSubmit",
+    hook_name_mapping: ClassVar[dict[SkillLifecycleHook, str]] = {
+        SkillLifecycleHook.AFTER_AGENT: "Stop",
+        SkillLifecycleHook.BEFORE_TOOL: "PreToolUse",
+        SkillLifecycleHook.BEFORE_PROMPT: "UserPromptSubmit",
     }
 
     def sync_hooks(self, project_path: Path, hooks: dict[str, list[dict[str, Any]]]) -> int:
@@ -330,11 +348,11 @@ class ClaudeAdapter(AgentAdapter):
 class GeminiAdapter(AgentAdapter):
     """Adapter for Gemini CLI.
 
-    Gemini CLI uses TOML format for custom commands stored in .gemini/commands/.
-    Commands use colon (:) for namespacing instead of dot (.).
+    Gemini CLI uses TOML format for custom skills stored in .gemini/skills/.
+    Skills use colon (:) for namespacing instead of dot (.).
 
-    Note: Gemini CLI does NOT support command-level hooks. Hooks are configured
-    globally in settings.json, not per-command. Therefore, hook_name_mapping
+    Note: Gemini CLI does NOT support skill-level hooks. Hooks are configured
+    globally in settings.json, not per-skill. Therefore, hook_name_mapping
     is empty and sync_hooks returns 0.
 
     See: doc/platforms/gemini/hooks_system.md
@@ -343,30 +361,49 @@ class GeminiAdapter(AgentAdapter):
     name = "gemini"
     display_name = "Gemini CLI"
     config_dir = ".gemini"
-    command_template = "command-job-step.toml.jinja"
+    skill_template = "skill-job-step.toml.jinja"
+    meta_skill_template = "skill-job-meta.toml.jinja"
 
     # Gemini CLI can reload with /memory refresh
     reload_instructions: ClassVar[str] = (
-        "Run '/memory refresh' to reload commands, or restart your Gemini CLI session."
+        "Run '/memory refresh' to reload skills, or restart your Gemini CLI session."
     )
 
-    # Gemini CLI does NOT support command-level hooks
-    # Hooks are global/project-level in settings.json, not per-command
-    hook_name_mapping: ClassVar[dict[CommandLifecycleHook, str]] = {}
+    # Gemini CLI does NOT support skill-level hooks
+    # Hooks are global/project-level in settings.json, not per-skill
+    hook_name_mapping: ClassVar[dict[SkillLifecycleHook, str]] = {}
+
+    def get_meta_skill_filename(self, job_name: str) -> str:
+        """
+        Get the filename for a Gemini job's meta-skill.
+
+        Gemini uses TOML files and colon namespacing via subdirectories.
+        For job "my_job", creates: my_job/index.toml
+
+        Args:
+            job_name: Name of the job
+
+        Returns:
+            Meta-skill filename path (e.g., "my_job/index.toml")
+        """
+        return f"{job_name}/index.toml"
 
-    def get_command_filename(self, job_name: str, step_id: str) -> str:
+    def get_step_skill_filename(self, job_name: str, step_id: str, exposed: bool = False) -> str:
         """
-        Get the filename for a Gemini command.
+        Get the filename for a Gemini step skill.
 
         Gemini uses TOML files and colon namespacing via subdirectories.
+        All step skills use the same filename format. The exposed parameter
+        is used for template context (user-invocable setting).
         For job "my_job" and step "step_one", creates: my_job/step_one.toml
 
         Args:
             job_name: Name of the job
             step_id: ID of the step
+            exposed: If True, skill is user-invocable (for template context). Default: False.
 
         Returns:
-            Command filename path (e.g., "my_job/step_one.toml")
+            Skill filename path (e.g., "my_job/step_one.toml")
         """
         return f"{job_name}/{step_id}.toml"
 
@@ -374,7 +411,7 @@ class GeminiAdapter(AgentAdapter):
         """
         Sync hooks to Gemini CLI settings.
 
-        Gemini CLI does not support command-level hooks. All hooks are
+        Gemini CLI does not support skill-level hooks. All hooks are
         configured globally in settings.json. This method is a no-op
         that always returns 0.
 
@@ -383,8 +420,8 @@ class GeminiAdapter(AgentAdapter):
             hooks: Dict mapping lifecycle events to hook configurations (ignored)
 
         Returns:
-            0 (Gemini does not support command-level hooks)
+            0 (Gemini does not support skill-level hooks)
         """
-        # Gemini CLI does not support command-level hooks
-        # Hooks are configured globally in settings.json, not per-command
+        # Gemini CLI does not support skill-level hooks
+        # Hooks are configured globally in settings.json, not per-skill
         return 0