god-code 0.5.0__tar.gz → 0.5.1__tar.gz

god_code-0.5.1/CLAUDE.md

@@ -0,0 +1,196 @@
+# CLAUDE.md — God Code Development Guide
+
+> AI coding agent specialized for Godot 4.4 game development. This file guides Claude Code when working on the god-code codebase itself.
+
+## Project Identity
+
+**god-code** — a Python CLI agent that understands GDScript, .tscn scenes, collision layers, and Godot architecture patterns. Multi-provider LLM support with 29 Godot-specific tools, AI sprite generation, and incremental build-and-verify discipline.
+
+**PyPI**: `pip install god-code`
+**GitHub**: https://github.com/888wing/god-code
+**License**: GPL-3.0
+
+## Tech Stack
+
+- **Language**: Python 3.9+ (uses `from __future__ import annotations` for 3.10+ syntax)
+- **CLI**: click
+- **HTTP**: httpx (async)
+- **Models**: pydantic v2 (tool schemas, config, structured outputs)
+- **Image**: Pillow (screenshot + sprite post-processing)
+- **TUI**: rich (panels, markdown, diff, tables, spinner) + prompt_toolkit (history, autocomplete)
+- **Test**: pytest + pytest-asyncio (383 tests)
+- **Build**: hatchling
+- **CI**: GitHub Actions (auto-publish to PyPI on tag)
+
+## Current Version: 0.5.1
+
+**Stats**: 70 source files, 55 test files, ~11K lines, 383 tests, 29 tools.
+
+## Architecture
+
+```
+godot_agent/
+├── cli.py                          # Click CLI + setup wizard + chat loop
+├── agents/                         # Multi-agent system
+│   ├── configs.py                  # Agent role configurations
+│   ├── dispatcher.py               # Planner/worker/reviewer dispatch
+│   └── results.py                  # Agent result types
+├── runtime/
+│   ├── engine.py                   # Conversation loop (tools, streaming, quality gates, review)
+│   ├── config.py                   # AgentConfig (pydantic) + env overrides
+│   ├── session.py                  # Session persistence with metadata
+│   ├── oauth.py                    # Codex refresh token flow
+│   ├── error_loop.py               # Godot output parsing + fix suggestions
+│   ├── context_manager.py          # Smart compression with working memory (1.05M context)
+│   ├── events.py                   # Engine event system for TUI
+│   ├── modes.py                    # Interaction modes (apply/plan/explain/review/fix)
+│   ├── providers.py                # Provider detection (openai/anthropic/gemini/xai/openrouter)
+│   ├── quality_gate.py             # Post-tool validation pipeline
+│   ├── reviewer.py                 # Automated code review
+│   ├── playtest_harness.py         # Automated gameplay testing
+│   ├── gameplay_reviewer.py        # Gameplay quality analysis
+│   ├── runtime_bridge.py           # Runtime state snapshots
+│   ├── design_memory.py            # Persistent design decisions
+│   └── auth.py                     # Auth context
+├── llm/
+│   ├── client.py                   # LLMClient with retry, content filter handling
+│   ├── types.py                    # Message, ToolCall, TokenUsage, ChatResponse, LLMConfig
+│   ├── streaming.py                # SSE streaming with tool call assembly
+│   ├── vision.py                   # Image encoding
+│   └── adapters/                   # Provider-specific adapters
+│       ├── base.py                 # Adapter interface
+│       ├── openai.py               # OpenAI/OpenRouter adapter
+│       └── anthropic.py            # Anthropic adapter
+├── tools/                          # 29 function-calling tools
+│   ├── base.py                     # BaseTool ABC (strict mode support)
+│   ├── registry.py                 # ToolRegistry with security pipeline
+│   ├── file_ops.py                 # read_file, write_file, edit_file (path-contained)
+│   ├── script_tools.py             # read_script, edit_script, lint_script
+│   ├── scene_tools.py              # read_scene, scene_tree, add/write/remove scene nodes
+│   ├── analysis_tools.py           # validate_project, check_consistency, dependency_graph, impact
+│   ├── search.py                   # grep, glob
+│   ├── list_dir.py                 # list_dir
+│   ├── git.py                      # git (shlex-parsed)
+│   ├── shell.py                    # run_shell (3 safety levels)
+│   ├── godot_cli.py                # run_godot (GUT, validate, output parser)
+│   ├── screenshot.py               # screenshot_scene (headless)
+│   ├── image_gen.py                # generate_sprite (AI pixel art + post-processing)
+│   ├── web_search.py               # web_search (Godot docs, web)
+│   ├── memory_tool.py              # design memory read/write
+│   └── editor_bridge.py            # runtime snapshot, playtest
+├── godot/                          # Godot-specific analysis
+│   ├── project.py                  # project.godot parser
+│   ├── scene_parser.py             # .tscn → TscnScene
+│   ├── scene_writer.py             # Structured .tscn modification
+│   ├── tscn_validator.py           # Format validation + auto-fix
+│   ├── gdscript_linter.py          # Style, naming, type annotations
+│   ├── collision_planner.py        # Standard 8-layer scheme
+│   ├── consistency_checker.py      # Cross-file checks
+│   ├── dependency_graph.py         # Project-wide file graph
+│   ├── pattern_advisor.py          # Design pattern suggestions
+│   ├── impact_analysis.py          # Change impact analysis
+│   └── resource_validator.py       # res:// path checks
+├── prompts/
+│   ├── system.py                   # Compatibility wrapper
+│   ├── assembler.py                # Full prompt assembly pipeline
+│   ├── godot_playbook.py           # 17 knowledge sections
+│   ├── knowledge_selector.py       # Context-aware section scoring
+│   ├── skill_library.py            # Skill definitions
+│   ├── skill_selector.py           # Dynamic skill activation
+│   ├── build_discipline.py         # Build-and-verify rules
+│   └── image_templates.py          # Pixel art prompt templates
+├── security/
+│   ├── classifier.py               # Tool risk classification
+│   ├── hooks.py                    # Pre/post execution hooks
+│   ├── policies.py                 # Execution context + policies
+│   ├── protected_paths.py          # Path protection rules
+│   └── tool_pipeline.py            # Tool execution pipeline
+├── testing/
+│   └── scenario_runner.py          # Automated test scenarios
+└── tui/
+    ├── display.py                  # Rich TUI components
+    └── input_handler.py            # prompt_toolkit input + autocomplete
+```
+
+## Key Patterns
+
+### Tool System
+Every tool inherits `BaseTool`. Supports `strict` mode for GPT-5+ structured outputs. Security pipeline validates path containment and safety level before execution.
+
+### Provider Adapters
+`llm/adapters/` handles provider-specific request/response formats:
+- OpenAI: `max_completion_tokens` for gpt-5+, `max_tokens` for others
+- Anthropic: `thinking` budget for reasoning models
+- Gemini: `reasoning_effort` parameter
+
+### Engine Loop Phases
+```
+PREPARE_CONTEXT → CALL_MODEL → EXECUTE_TOOLS → RUN_QUALITY_GATE → RUN_REVIEWER → NEXT_ROUND → DONE
+```
+
+### Context Management (1.05M window)
+Smart compression at 75% (787K tokens):
+1. Extract working memory (modified files, decisions, errors)
+2. Keep 20 recent messages intact
+3. Replace old turns with memory summary
+4. Tell LLM to re-read files if needed
+
+### Interaction Modes
+- `apply`: Full tool access, write code
+- `plan`: Read-only tools, design first
+- `explain`: Read-only, educational
+- `review`: Read-only, quality analysis
+- `fix`: Full tools, error-focused
+
+## Development Rules
+
+### Adding a New Tool
+1. Create in `godot_agent/tools/your_tool.py` inheriting `BaseTool`
+2. Define `Input`/`Output` as pydantic `BaseModel` (all fields must have defaults for strict mode)
+3. Implement `async execute()`, `is_read_only()`, `is_destructive()`
+4. Register in `cli.py:build_registry()`
+5. Add to `prompts/system.py` active_tools list
+6. Add tests in `tests/tools/`
+
+### Adding a Provider
+1. Create adapter in `godot_agent/llm/adapters/`
+2. Register in `runtime/providers.py`
+3. Add detection rules (model prefix, base_url pattern)
+
+## Config Reference
+
+`~/.config/god-code/config.json`:
+
+| Field | Default | Description |
+|-------|---------|-------------|
+| api_key | "" | LLM API key |
+| provider | "openai" | openai, anthropic, gemini, xai, openrouter |
+| model | "gpt-5.4" | Model ID |
+| reasoning_effort | "high" | low, medium, high |
+| mode | "apply" | apply, plan, explain, review, fix |
+| language | "en" | en, zh-TW, ja, ko |
+| verbosity | "normal" | concise, normal, detailed |
+| auto_validate | true | Run Godot after file changes |
+| auto_commit | false | Suggest git commit |
+| token_budget | 0 | Max tokens (0=unlimited) |
+| safety | "normal" | strict, normal, permissive |
+| streaming | true | Stream responses |
+| extra_prompt | "" | Custom instructions |
+
+## Testing
+
+```bash
+python -m pytest tests/ -v          # Full suite (383 tests)
+python -m pytest tests/tools/ -v    # Tool tests only
+python -m pytest tests/e2e/ -v      # E2E integration tests
+```
+
+## Release
+
+```bash
+# Bump version in pyproject.toml + cli.py _VERSION
+git commit -am "release: v0.5.1"
+git tag v0.5.1
+git push && git push --tags
+# → GitHub Actions auto-publishes to PyPI
+```

{god_code-0.5.0 → god_code-0.5.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: god-code
-Version: 0.5.0
+Version: 0.5.1
 Summary: AI coding agent specialized for Godot game development
 Project-URL: Homepage, https://github.com/chuisiufai/god-code
 Project-URL: Repository, https://github.com/chuisiufai/god-code

{god_code-0.5.0 → god_code-0.5.1}/README.md

@@ -4,15 +4,20 @@ AI coding agent specialized for Godot 4.4 game development. Unlike generic codin
 
 ## Features
 
-- **10 tools**: read/write/edit files, grep/glob search, git, shell, Godot headless runner, screenshot capture
-- **Workspace-style chat TUI**: session snapshot, recent activity timeline, live tool feedback, and validation visibility
-- **Interaction modes**: `apply`, `plan`, `explain`, `review`, and `fix` with mode-aware prompts and tool access
-- **Session recovery**: autosave, `/sessions`, `/resume`, and project-aware session metadata
+- **29 tools**: file ops, scene manipulation, script editing, search, git, shell, Godot headless runner, screenshot, AI sprite generation, web search
+- **AI sprite generation**: pixel art pipeline with chroma key removal, auto-crop, nearest-neighbor resize, style presets
+- **Structured Outputs**: strict JSON schemas for gpt-5+ models — zero tool call parse errors
+- **Web search**: query Godot docs and web when built-in knowledge isn't enough
+- **Workspace-style chat TUI**: session snapshot, activity timeline, live tool feedback, streaming output
+- **Interaction modes**: `apply`, `plan`, `explain`, `review`, `fix` with mode-aware prompts and tool access
+- **Multi-provider**: OpenAI (gpt-5.4), Anthropic (claude-sonnet-4.6), Google (gemini), xAI (grok), OpenRouter, local models
+- **Session recovery**: autosave, `/sessions`, `/resume`, project-aware session metadata
 - **Godot-native understanding**: project.godot parser, .tscn scene parser/writer/validator, collision layer planner
-- **Code quality**: GDScript linter (naming, ordering, type annotations), cross-file consistency checker, design pattern advisor
-- **Smart knowledge injection**: 17 Godot Playbook sections auto-selected by task context
-- **Build discipline**: incremental build-and-verify rules enforced via system prompt
-- **Vision support**: send screenshots + reference images to multimodal LLMs
+- **Code quality**: GDScript linter, cross-file consistency checker, design pattern advisor, impact analysis
+- **Smart knowledge injection**: 17 Godot Playbook sections auto-selected by task context + skill system
+- **Build discipline**: incremental build-and-verify with quality gates and automated review
+- **Security**: path containment, shell command blocking (3 safety levels), tool execution pipeline
+- **1.05M context window**: smart compression with working memory extraction at 75% threshold
 
 ## Install
 

{god_code-0.5.0 → god_code-0.5.1}/godot_agent/agents/dispatcher.py

@@ -85,7 +85,8 @@ class AgentDispatcher:
             prompt_assembler=prompt_assembler,
             mode=config.mode,
         )
-        engine.allowed_tools = allowed_tools
+        engine.base_allowed_tools = set(allowed_tools)
+        engine.allowed_tools = set(allowed_tools)
         return engine
 
     async def run_planner(self, task: str) -> AgentTaskResult:

{god_code-0.5.0 → god_code-0.5.1}/godot_agent/cli.py

@@ -104,6 +104,50 @@ def _has_meaningful_input(value: str) -> bool:
     return any(ch.isprintable() and not ch.isspace() for ch in value)
 
 
+def _command_argument(value: str, command: str) -> str | None:
+    stripped = value.strip()
+    if stripped == command:
+        return ""
+    prefix = f"{command} "
+    if not stripped.startswith(prefix):
+        return None
+    parts = stripped.split(None, 1)
+    return parts[1].strip() if len(parts) > 1 else ""
+
+
+def _set_arguments(value: str) -> tuple[str, str] | None:
+    stripped = value.strip()
+    if stripped == "/set":
+        return None
+    if not stripped.startswith("/set "):
+        return None
+    parts = stripped.split(None, 2)
+    if len(parts) != 3:
+        return None
+    return parts[1], parts[2]
+
+
+def _cd_argument(value: str) -> str | None:
+    for command in ("/cd", "cd"):
+        arg = _command_argument(value, command)
+        if arg is not None:
+            return arg
+    return None
+
+
+def _starts_multiline_input(value: str) -> bool:
+    return value.strip().startswith('"""')
+
+
+def _multiline_initial_fragment(value: str) -> str:
+    stripped = value.strip()
+    return stripped[3:] if stripped.startswith('"""') else ""
+
+
+def _is_multiline_terminator(value: str | None) -> bool:
+    return value is None or value.strip() == '"""'
+
+
 def build_registry() -> ToolRegistry:
     registry = ToolRegistry()
     for tool_cls in [
@@ -174,7 +218,8 @@ def build_engine(config: AgentConfig, project_root: Path) -> ConversationEngine:
         mode=config.mode,
         dispatcher=dispatcher,
     )
-    engine.allowed_tools = allowed_tools
+    engine.base_allowed_tools = set(allowed_tools)
+    engine.allowed_tools = set(allowed_tools)
     return engine
 
 
@@ -407,7 +452,7 @@ def _run_setup_wizard() -> None:
     click.echo()
 
 
-_VERSION = "0.5.0"
+_VERSION = "0.5.1"
 
 
 def _check_update() -> None:
@@ -690,7 +735,7 @@ def chat(project: str = ".", config: str | None = None):
                     if in_multiline:
                         from godot_agent.tui.input_handler import get_multiline_continuation_async
                         line = await get_multiline_continuation_async(input_session)
-                        if line is None or line.strip() == '"""':
+                        if _is_multiline_terminator(line):
                             in_multiline = False
                             user_input = "\n".join(multiline_buffer)
                             multiline_buffer = []
@@ -702,9 +747,9 @@ def chat(project: str = ".", config: str | None = None):
                         user_input = await get_input_async(input_session, completer, bottom_toolbar=_toolbar())
                         if user_input is None:
                             break
-                        if user_input.strip().startswith('"""'):
+                        if _starts_multiline_input(user_input):
                             in_multiline = True
-                            rest = user_input.strip()[3:]
+                            rest = _multiline_initial_fragment(user_input)
                             if rest:
                                 multiline_buffer.append(rest)
                             continue
@@ -727,10 +772,9 @@ def chat(project: str = ".", config: str | None = None):
 
                 if cmd in ("/load", "/resume", "resume"):
                     target = "latest"
-                elif stripped.startswith("/resume "):
-                    target = stripped.split(None, 1)[1].strip()
                 else:
-                    target = None
+                    resume_arg = _command_argument(user_input, "/resume")
+                    target = resume_arg or "latest" if resume_arg is not None else None
 
                 if target is not None:
                     record = (
@@ -803,13 +847,14 @@ def chat(project: str = ".", config: str | None = None):
                         display.error(f"No project.godot in {project_root}")
                     continue
 
-                if cmd == "/mode":
+                mode_arg = _command_argument(user_input, "/mode")
+                if cmd == "/mode" or mode_arg == "":
                     display.mode_panel(cfg.mode)
                     continue
 
-                if stripped.startswith("/mode "):
+                if mode_arg:
                     try:
-                        cfg.mode = normalize_mode(stripped.split(None, 1)[1])
+                        cfg.mode = normalize_mode(mode_arg)
                     except ValueError as e:
                         display.error(str(e))
                         continue
@@ -819,7 +864,8 @@ def chat(project: str = ".", config: str | None = None):
                     _refresh_workspace()
                     continue
 
-                if cmd == "/provider":
+                provider_arg = _command_argument(user_input, "/provider")
+                if cmd == "/provider" or provider_arg == "":
                     display.info_panel({
                         "Provider": cfg.provider,
                         "Base URL": cfg.base_url,
@@ -828,9 +874,9 @@ def chat(project: str = ".", config: str | None = None):
                     })
                     continue
 
-                if stripped.startswith("/provider "):
+                if provider_arg:
                     try:
-                        provider = _apply_provider_preset(cfg, stripped.split(None, 1)[1])
+                        provider = _apply_provider_preset(cfg, provider_arg)
                     except ValueError as e:
                         display.error(str(e))
                         continue
@@ -839,7 +885,8 @@ def chat(project: str = ".", config: str | None = None):
                     _refresh_workspace()
                     continue
 
-                if cmd == "/model":
+                model_arg = _command_argument(user_input, "/model")
+                if cmd == "/model" or model_arg == "":
                     display.info_panel({
                         "Provider": cfg.provider,
                         "Model": cfg.model,
@@ -847,10 +894,10 @@ def chat(project: str = ".", config: str | None = None):
                     })
                     continue
 
-                if stripped.startswith("/model "):
+                if model_arg is not None:
                     previous_provider = cfg.provider
                     previous_base_url = cfg.base_url
-                    cfg.model = stripped.split(None, 1)[1].strip()
+                    cfg.model = model_arg
                     if not cfg.model:
                         display.error("Usage: /model <name>")
                         continue
@@ -860,7 +907,8 @@ def chat(project: str = ".", config: str | None = None):
                     _refresh_workspace()
                     continue
 
-                if cmd == "/effort":
+                effort_arg = _command_argument(user_input, "/effort")
+                if cmd == "/effort" or effort_arg == "":
                     display.info_panel({
                         "Effort": cfg.reasoning_effort,
                         "Allowed": ", ".join(REASONING_EFFORT_LEVELS),
@@ -868,9 +916,11 @@ def chat(project: str = ".", config: str | None = None):
                     })
                     continue
 
-                if stripped.startswith("/effort "):
+                if effort_arg is not None:
                     try:
-                        cfg.reasoning_effort = _normalize_reasoning_effort(stripped.split(None, 1)[1])
+                        if not effort_arg:
+                            raise ValueError("Usage: /effort <level>")
+                        cfg.reasoning_effort = _normalize_reasoning_effort(effort_arg)
                     except ValueError as e:
                         display.error(str(e))
                         continue
@@ -910,82 +960,79 @@ def chat(project: str = ".", config: str | None = None):
                     display.settings_panel(cfg)
                     continue
 
-                if stripped.startswith("/set "):
-                    parts = stripped.split(None, 2)
-                    if len(parts) == 3:
-                        key, val = parts[1], parts[2]
-                        if hasattr(cfg, key):
-                            old_val = getattr(cfg, key)
-                            try:
-                                if key == "mode":
-                                    setattr(cfg, key, normalize_mode(val))
-                                elif key == "provider":
-                                    _apply_provider_preset(cfg, val)
-                                elif key == "reasoning_effort":
-                                    setattr(cfg, key, _normalize_reasoning_effort(val))
-                                elif key == "model":
-                                    previous_provider = cfg.provider
-                                    previous_base_url = cfg.base_url
-                                    setattr(cfg, key, val)
-                                    _sync_provider_from_model(cfg, previous_provider, previous_base_url)
-                                elif isinstance(old_val, bool):
-                                    setattr(cfg, key, val.lower() in ("true", "1", "yes", "on"))
-                                elif isinstance(old_val, int):
-                                    setattr(cfg, key, int(val))
-                                elif isinstance(old_val, float):
-                                    setattr(cfg, key, float(val))
-                                else:
-                                    setattr(cfg, key, val)
-                            except ValueError as e:
-                                display.error(str(e))
-                                continue
-
-                            display.success(f"{key} = {getattr(cfg, key)}")
-                            if key == "base_url":
-                                cfg.provider = infer_provider(
-                                    base_url=cfg.base_url,
-                                    model=cfg.model,
-                                    provider="",
-                                )
-
-                            if key in (
-                                "language",
-                                "verbosity",
-                                "extra_prompt",
-                                "auto_validate",
-                                "mode",
-                                "safety",
-                                "godot_path",
-                                "provider",
-                                "model",
-                                "base_url",
-                                "reasoning_effort",
-                                "api_key",
-                                "oauth_token",
-                                "max_tokens",
-                                "temperature",
-                            ):
-                                await _replace_engine(project_root, preserve_messages=True, rescan_project=False)
-                                display.info("Engine rebuilt with updated settings")
+                set_args = _set_arguments(user_input)
+                if stripped == "/set" or set_args is not None:
+                    if set_args is None:
+                        display.error("Usage: /set <key> <value>")
+                        continue
+                    key, val = set_args
+                    if hasattr(cfg, key):
+                        old_val = getattr(cfg, key)
+                        try:
+                            if key == "mode":
+                                setattr(cfg, key, normalize_mode(val))
+                            elif key == "provider":
+                                _apply_provider_preset(cfg, val)
+                            elif key == "reasoning_effort":
+                                setattr(cfg, key, _normalize_reasoning_effort(val))
+                            elif key == "model":
+                                previous_provider = cfg.provider
+                                previous_base_url = cfg.base_url
+                                setattr(cfg, key, val)
+                                _sync_provider_from_model(cfg, previous_provider, previous_base_url)
+                            elif isinstance(old_val, bool):
+                                setattr(cfg, key, val.lower() in ("true", "1", "yes", "on"))
+                            elif isinstance(old_val, int):
+                                setattr(cfg, key, int(val))
+                            elif isinstance(old_val, float):
+                                setattr(cfg, key, float(val))
                             else:
-                                _wire_engine_callbacks(engine, display, cfg)
-                            _refresh_workspace()
+                                setattr(cfg, key, val)
+                        except ValueError as e:
+                            display.error(str(e))
+                            continue
+
+                        display.success(f"{key} = {getattr(cfg, key)}")
+                        if key == "base_url":
+                            cfg.provider = infer_provider(
+                                base_url=cfg.base_url,
+                                model=cfg.model,
+                                provider="",
+                            )
+
+                        if key in (
+                            "language",
+                            "verbosity",
+                            "extra_prompt",
+                            "auto_validate",
+                            "mode",
+                            "safety",
+                            "godot_path",
+                            "provider",
+                            "model",
+                            "base_url",
+                            "reasoning_effort",
+                            "api_key",
+                            "oauth_token",
+                            "max_tokens",
+                            "temperature",
+                        ):
+                            await _replace_engine(project_root, preserve_messages=True, rescan_project=False)
+                            display.info("Engine rebuilt with updated settings")
                         else:
-                            display.error(f"Unknown setting: {key}")
+                            _wire_engine_callbacks(engine, display, cfg)
+                        _refresh_workspace()
                     else:
-                        display.error("Usage: /set <key> <value>")
+                        display.error(f"Unknown setting: {key}")
                     continue
 
                 # Support both /cd and cd
-                cd_input = stripped
-                if cd_input.startswith("/cd "):
-                    cd_input = cd_input[4:]
-                elif cd_input.startswith("cd "):
-                    cd_input = cd_input[3:]
-                else:
-                    cd_input = None
+                cd_input = _cd_argument(user_input)
 
                 if cd_input is not None:
+                    if not cd_input:
+                        display.error("Usage: /cd <path>")
+                        continue
                     new_path = Path(cd_input).expanduser().resolve()
                     if not new_path.exists():
                         display.error(f"Path not found: {new_path}")

{god_code-0.5.0 → god_code-0.5.1}/godot_agent/prompts/assembler.py

@@ -9,6 +9,7 @@ from godot_agent.godot.impact_analysis import ImpactAnalysisReport, format_impac
 from godot_agent.godot.project import parse_project_godot
 from godot_agent.prompts.build_discipline import BUILD_DISCIPLINE_PROMPT
 from godot_agent.prompts.knowledge_selector import format_knowledge_injection, select_sections
+from godot_agent.prompts.skill_selector import format_skill_injection, select_skills
 from godot_agent.runtime.design_memory import DesignMemory, format_design_memory
 from godot_agent.runtime.modes import mode_prompt
 from godot_agent.runtime.playtest_harness import PlaytestReport, format_playtest_report
@@ -75,6 +76,10 @@ class PromptAssembler:
     ) -> str:
         sections = [self._static_prompt]
 
+        skills = select_skills(user_hint, file_paths, max_skills=2)
+        if skills:
+            sections.append(format_skill_injection(skills))
+
         knowledge_sections = select_sections(user_hint, file_paths, max_sections=4)
         if knowledge_sections:
             sections.append(format_knowledge_injection(knowledge_sections))