voidx 2.1.1__tar.gz → 2.2.0__tar.gz

{voidx-2.1.1 → voidx-2.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: voidx
-Version: 2.1.1
+Version: 2.2.0
 Summary: A coding agent that quantifies everything and solves with tools, not fuzzy prompts.
 Requires-Python: >=3.11
 Description-Content-Type: text/markdown

{voidx-2.1.1 → voidx-2.2.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "voidx"
-version = "2.1.1"
+version = "2.2.0"
 description = "A coding agent that quantifies everything and solves with tools, not fuzzy prompts."
 readme = "README.md"
 requires-python = ">=3.11"
@@ -44,8 +44,7 @@ where = ["src"]
 
 [tool.setuptools.package-data]
 "voidx.skills" = [
-    "bundled/superpowers/*/SKILL.md",
-    "bundled/superpowers/*/templates/*.md",
+    "bundled/*/SKILL.md",
 ]
 "voidx.data" = [
     "intent_classifier.json",

{voidx-2.1.1 → voidx-2.2.0}/src/voidx/__init__.py

@@ -1,3 +1,3 @@
 """VoidX - A coding agent that quantifies everything."""
 
-__version__ = "2.1.1"
+__version__ = "2.2.0"

{voidx-2.1.1 → voidx-2.2.0}/src/voidx/agent/agents.py

@@ -50,12 +50,12 @@ BASE_SYSTEM_PROMPT = """You are voidx, a coding agent that lives in the terminal
 
 ## Workflow Skills
 
-- voidx may activate workflow skills such as systematic-debugging,
-  test-driven-development, verification-before-completion,
-  receiving-code-review, requesting-code-review, and writing-plans.
-- The Current Task State lists active workflow skills for this turn.
-- The Active Skills section contains the full instructions for active skills.
-- Follow active workflow skills before acting.
+- voidx has a workflow skill system.
+- Current Task State is the activation source for this turn's workflow skills.
+- Skill Context messages contain bundled workflow skill bodies as a reference
+  library. Follow only skills listed as active in Current Task State, unless the
+  user explicitly references another skill.
+- load_skills can return project/global skill bodies for the current turn.
 """
 
 
@@ -339,7 +339,7 @@ BUILTIN_AGENTS: dict[str, AgentDef] = {
         when_to_use="Default agent for all user interactions. Always use first.",
         tools=[
             "on_intent", "clarify", "plan_checkpoint",
-            "read", "glob", "grep", "bash", "agent", "task_status", "todo",
+            "read", "glob", "grep", "bash", "agent", "task_status", "todo", "load_skills",
             "webfetch", "websearch", "repo_map",
             "lsp_diagnostics", "lsp_symbols", "lsp_definition", "lsp_references",
             "write", "edit", "apply_patch", "lsp_format",
@@ -358,7 +358,7 @@ BUILTIN_AGENTS: dict[str, AgentDef] = {
                     "or answer 'how does X work' questions. Specify thoroughness: "
                     "'quick' for basic, 'medium' for moderate, 'very thorough' for exhaustive.",
         tools=[
-            "read", "glob", "grep", "webfetch", "websearch", "repo_map",
+            "read", "glob", "grep", "load_skills", "webfetch", "websearch", "repo_map",
             "lsp_diagnostics", "lsp_symbols", "lsp_definition", "lsp_references",
         ],
         can_write=False,
@@ -374,7 +374,7 @@ BUILTIN_AGENTS: dict[str, AgentDef] = {
         when_to_use="Use for design/architecture questions, before complex implementations, "
                     "or when the user asks for a plan/approach/solution design.",
         tools=[
-            "read", "glob", "grep", "webfetch", "websearch", "repo_map",
+            "read", "glob", "grep", "load_skills", "webfetch", "websearch", "repo_map",
             "lsp_diagnostics", "lsp_symbols", "lsp_definition", "lsp_references",
         ],
         can_write=False,
@@ -388,7 +388,7 @@ BUILTIN_AGENTS: dict[str, AgentDef] = {
         when_to_use="Use for all code writing, file editing, refactoring, bug fixing, "
                     "and bash execution. Give complete, self-contained task descriptions.",
         tools=[
-            "read", "write", "edit", "apply_patch", "glob", "grep", "bash", "todo", "repo_map",
+            "read", "write", "edit", "apply_patch", "glob", "grep", "bash", "todo", "load_skills", "repo_map",
             "lsp_diagnostics", "lsp_symbols", "lsp_definition", "lsp_references",
             "lsp_format",
         ],
@@ -404,7 +404,7 @@ BUILTIN_AGENTS: dict[str, AgentDef] = {
         when_to_use="ALWAYS invoke after implement finishes non-trivial work. "
                     "Use to verify correctness before reporting completion to the user.",
         tools=[
-            "read", "glob", "grep", "bash", "webfetch", "websearch", "repo_map",
+            "read", "glob", "grep", "bash", "load_skills", "webfetch", "websearch", "repo_map",
             "lsp_diagnostics", "lsp_symbols", "lsp_definition", "lsp_references",
         ],
         can_write=False,

{voidx-2.1.1 → voidx-2.2.0}/src/voidx/agent/graph/core.py

@@ -59,6 +59,7 @@ from voidx.agent.graph.wiring import (
 )
 from voidx.agent.state import AgentState
 from voidx.agent.graph.streaming import extract_text, stream_llm as _stream_llm
+from voidx.agent.graph.subagent import _task_intent_for_agent as _subagent_task_intent_for_agent
 from voidx.agent.graph.subagent import run_subagent as _run_subagent
 from voidx.agent.graph.title_mixin import GraphTitleMixin
 from voidx.agent.graph.tool_execution import GraphToolExecutionMixin
@@ -117,6 +118,20 @@ def _merge_skill_runs(*groups: list[SkillRunState | dict]) -> list[SkillRunState
     return list(merged.values())
 
 
+def _skill_names(group: list[SkillRunState | dict]) -> list[str]:
+    names: list[str] = []
+    for item in group:
+        if isinstance(item, SkillRunState):
+            name = item.name
+        elif isinstance(item, dict):
+            name = item.get("name", "")
+        else:
+            name = ""
+        if isinstance(name, str) and name.strip():
+            names.append(name.strip())
+    return names
+
+
 class VoidXGraph(
     GraphTitleMixin,
     GraphRunLoopMixin,
@@ -147,6 +162,7 @@ class VoidXGraph(
 
         self._interaction_mode: InteractionMode = InteractionMode.AUTO
         self._debug: bool = False
+        self._instruction.set_debug(self._debug)
         ui.set_debug(self._debug)
 
         self._file_mtimes: dict[str, float] = {}
@@ -372,6 +388,16 @@ class VoidXGraph(
         self._next_agent_id += 1
         parent_tool_call_id = _current_parent_tool_call_id.get()
         started_at = time.monotonic()
+        interaction_mode = InteractionMode.PLAN.value if agent_def.name == "plan" else InteractionMode.AUTO.value
+        task_intent = _subagent_task_intent_for_agent(agent_def.name)
+        skill_runtime_context = await self._instruction.skill_context_for(
+            description,
+            agent=agent_def.name,
+            task_intent=task_intent,
+            interaction_mode=interaction_mode,
+            scope=description,
+            turn_count=getattr(getattr(self, "_task_run", None), "turn_count", 0),
+        )
 
         async def authorize(calls, agent_name: str):
             return await self._authorize_tool_calls(
@@ -403,8 +429,8 @@ class VoidXGraph(
                 "session_id": session_id if self._session else None,
                 "usage_stats": self._usage_stats,
                 "lsp_manager": getattr(self, "_lsp_manager", None),
-                "skill_selection": self._settings.get_skill_selection() if self._settings else None,
                 "parent_tools": self.tools,
+                "skill_runtime_context": skill_runtime_context,
             }
             if self._current_tree and self._turn_node:
                 kwargs.update({
@@ -435,6 +461,7 @@ class VoidXGraph(
 
     def set_debug(self, value: bool) -> None:
         self._debug = value
+        self._instruction.set_debug(value)
         ui.set_debug(value)
 
     def _apply_max_steps_override(self, agent_def: AgentDef) -> AgentDef:
@@ -477,6 +504,7 @@ class VoidXGraph(
             interaction_mode=interaction_mode,
             scope=pending_approval_scope(state.get("pending_approval")) or state.get("goal") or current_user_text,
             turn_count=state.get("goal_turn_count", 0),
+            exclude_names=_skill_names(state.get("skill_runs", []) or []),
         )
         skill_runs = _merge_skill_runs(
             _restored_skill_runs(getattr(self, "_task_run", None)),
@@ -497,7 +525,7 @@ class VoidXGraph(
             agent=agent_name,
             interaction_mode=interaction_mode,
             instructions=instructions,
-            skill_instructions=skill_context.instructions,
+            skill_context_content=skill_context.content,
             skill_runs=skill_runs,
             active_skill_summaries=skill_context.active,
             summary=summary,

{voidx-2.1.1 → voidx-2.2.0}/src/voidx/agent/graph/subagent.py

@@ -26,6 +26,7 @@ from voidx.agent.tool_messages import sanitize_tool_message_content
 from voidx.agent.tool_filters import filter_unavailable_lsp_tools
 from voidx.config import Config
 from voidx.llm.provider import create_chat_model, resolve_protocol
+from voidx.llm.instruction import SkillRuntimeContext
 from voidx.llm.usage import (
     UsageStats,
     estimate_context_tokens,
@@ -33,9 +34,6 @@ from voidx.llm.usage import (
     extract_token_usage,
 )
 from voidx.memory.context_frames import save_context_frame_from_messages
-from voidx.skills.registry import SkillRegistry
-from voidx.skills.runtime import SkillRunState
-from voidx.skills.service import SkillService
 from voidx.tools.base import ToolContext
 from voidx.tools.registry import ToolRegistry
 from voidx.tools.task_tracker import TaskTracker
@@ -59,8 +57,8 @@ async def run_subagent(
     session_id: str | None = None,
     usage_stats: UsageStats | None = None,
     lsp_manager=None,
-    skill_selection=None,
     parent_tools: ToolRegistry | None = None,
+    skill_runtime_context: SkillRuntimeContext | None = None,
 ) -> str:
     """Run a child agent. Child messages are appended to sub_messages
     (when provided) so the caller can place them after ToolMessages."""
@@ -140,16 +138,7 @@ async def run_subagent(
     interaction_mode = InteractionMode.PLAN.value if agent_def.name == "plan" else InteractionMode.AUTO.value
     mode_prompt = PLAN_MODE_APPEND if InteractionMode.parse(interaction_mode) == InteractionMode.PLAN else ""
     task_intent = _task_intent_for_agent(agent_def.name)
-    skill_service = SkillService(
-        SkillRegistry(config.workspace),
-        selection=skill_selection,
-    )
-    skill_matches = skill_service.select(
-        task_description,
-        agent=agent_def.name,
-        task_intent=task_intent,
-        interaction_mode=interaction_mode,
-    )
+    skills = skill_runtime_context or SkillRuntimeContext(instructions=[], active=[], content="", runs=[])
     context_cache = ContextCompilerCache()
     context, context_cache = RuntimeContextBuilder(
         config=context_config,
@@ -160,16 +149,9 @@ async def run_subagent(
         tool_contract=agent_def.tool_contract,
         agent=agent_def.name,
         interaction_mode=interaction_mode,
-        skill_instructions=[skill_service.render_instruction(match.skill) for match in skill_matches],
-        skill_runs=[
-            SkillRunState.from_match(
-                match,
-                phase="design" if interaction_mode == InteractionMode.PLAN.value else task_intent,
-                scope=task_description,
-            )
-            for match in skill_matches
-        ],
-        active_skill_summaries=[f"{match.name} ({match.reason})" for match in skill_matches],
+        skill_context_content=skills.content,
+        skill_runs=skills.runs,
+        active_skill_summaries=skills.active,
         current_user_text=task_description,
         task_intent=task_intent,
         session_date=datetime.now().astimezone().strftime("%Y-%m-%d %Z"),

{voidx-2.1.1 → voidx-2.2.0}/src/voidx/agent/graph/tool_execution.py

@@ -14,6 +14,7 @@ from voidx.agent.graph.runtime import current_parent_tool_call_id, ui
 from voidx.agent.graph.todo_events import todo_updated_event
 from voidx.agent.task_state import ToolStatePatch
 from voidx.agent.tool_messages import sanitize_tool_message_content
+from voidx.skills.runtime import SkillRunState
 from voidx.tools.base import ToolContext, UserInteraction, UserResponse
 from voidx.runtime.ui import (
     FileChangeAppended,
@@ -69,6 +70,7 @@ class GraphToolExecutionMixin:
             pending_approval=_dump_pending_approval(state.get("pending_approval")),
             goal=state.get("goal", ""),
             goal_turn_count=state.get("goal_turn_count", 0),
+            active_skill_names=_active_skill_names(state.get("skill_runs", []) or []),
             file_mtimes=self._file_mtimes,
             mcp_manager=getattr(self, "_mcp_manager", None),
             lsp_manager=getattr(self, "_lsp_manager", None),
@@ -287,7 +289,10 @@ class GraphToolExecutionMixin:
         ]
         deferred_msgs = [_deferred_message(tc, ctx.workspace) for tc in deferred_for_barrier]
 
-        state_update = _state_update_from_executed_tools(executed)
+        state_update = _state_update_from_executed_tools(
+            executed,
+            current_skill_runs=state.get("skill_runs", []) or [],
+        )
         return {
             "messages": [item.message for item in executed] + extra + denied_msgs + deferred_msgs,
             **state_update,
@@ -306,8 +311,14 @@ class GraphToolExecutionMixin:
         return True
 
 
-def _state_update_from_executed_tools(executed: list[_ExecutedTool]) -> dict:
+def _state_update_from_executed_tools(
+    executed: list[_ExecutedTool],
+    *,
+    current_skill_runs: object = (),
+) -> dict:
     update: dict = {}
+    merged_skill_runs = _merge_skill_runs_for_state(current_skill_runs)
+    skill_runs_changed = False
     for item in executed:
         metadata = getattr(item.result, "metadata", {}) or {}
         raw = metadata.get("state_patch")
@@ -325,12 +336,31 @@ def _state_update_from_executed_tools(executed: list[_ExecutedTool]) -> dict:
             elif field == "pending_approval":
                 update["pending_approval"] = data.get(field)
             elif field == "skill_runs":
-                update["skill_runs"] = patch.skill_runs
+                merged_skill_runs = _merge_skill_runs_for_state(
+                    merged_skill_runs,
+                    patch.skill_runs,
+                )
+                skill_runs_changed = True
             else:
                 update[field] = data.get(field)
+    if skill_runs_changed:
+        update["skill_runs"] = merged_skill_runs
     return update
 
 
+def _merge_skill_runs_for_state(*groups: object) -> list[SkillRunState]:
+    merged: dict[str, SkillRunState] = {}
+    for group in groups:
+        items = group.values() if isinstance(group, dict) else group or []
+        for item in items:
+            try:
+                run = item if isinstance(item, SkillRunState) else SkillRunState.model_validate(item)
+            except (TypeError, ValueError):
+                continue
+            merged[run.name] = run
+    return list(merged.values())
+
+
 def _parallel_subagent_limit(config) -> int:
     parallel = getattr(config, "parallel_subagents", None)
     if not bool(getattr(parallel, "enabled", False)):
@@ -430,3 +460,16 @@ def _dump_pending_approval(value: object | None) -> dict | None:
     if hasattr(value, "model_dump"):
         return value.model_dump(mode="json")
     return None
+
+
+def _active_skill_names(value: object) -> list[str]:
+    names: list[str] = []
+    items = value.values() if isinstance(value, dict) else value or []
+    for item in items:
+        if isinstance(item, dict):
+            name = item.get("name")
+        else:
+            name = getattr(item, "name", None)
+        if isinstance(name, str) and name.strip():
+            names.append(name.strip())
+    return names

{voidx-2.1.1 → voidx-2.2.0}/src/voidx/agent/graph/turn_mixin.py

@@ -31,6 +31,8 @@ from voidx.runtime.ui import (
     InputSet,
     StatusFinished,
     StatusUpdated,
+    TodoCleared,
+    TodoCommitted,
     TurnStarted,
     WarningAppended,
     dock,
@@ -73,9 +75,7 @@ class GraphTurnMixin:
         display_text: str | None = None,
     ) -> None:
         t_turn_start = time.monotonic()
-        t_turn_calls_start = self._usage_stats.total_calls
-        t_turn_in_start = self._usage_stats.total_input_tokens
-        t_turn_out_start = self._usage_stats.total_output_tokens
+        self._usage_stats.begin_turn()
         user_message_id: int | None = None
         try:
             session_tracker.begin_turn(self._workspace)
@@ -339,13 +339,11 @@ class GraphTurnMixin:
                     scheduler = getattr(self, "_schedule_session_title_generation", None)
                     if callable(scheduler):
                         scheduler(self._session.id, title_source, title)
-                await self._persist_transcript_snapshot()
-
             elapsed = time.monotonic() - t_turn_start
             stats = self._usage_stats
-            turn_calls = stats.total_calls - t_turn_calls_start
-            turn_in = stats.total_input_tokens - t_turn_in_start
-            turn_out = stats.total_output_tokens - t_turn_out_start
+            turn_calls = stats.turn_calls
+            turn_in = stats.turn_input_tokens
+            turn_out = stats.turn_output_tokens
             from voidx.llm.usage import format_token_count
             dock.append_message(
                 f"[dim]✻  {elapsed:.0f}s[/dim]"
@@ -361,6 +359,13 @@ class GraphTurnMixin:
                     "\n".join(change_lines),
                     markup=True,
                 )
+            if via_events():
+                await ui_events.emit(TodoCommitted())
+                await ui_events.drain()
+            else:
+                dock.commit_todo_state()
+            if self._session:
+                await self._persist_transcript_snapshot()
         except (KeyboardInterrupt, asyncio.CancelledError):
             if self._session is not None and user_message_id is not None:
                 await delete_messages_from(self._session.id, user_message_id)
@@ -378,6 +383,7 @@ class GraphTurnMixin:
                     }
             raise
         finally:
+            self._usage_stats.end_turn()
             pending_guidance = getattr(self, "_pending_guidance", None)
             if pending_guidance is not None:
                 if pending_guidance:
@@ -392,9 +398,11 @@ class GraphTurnMixin:
                 await ui_events.emit(StatusFinished(status_id="turn:analyzing"))
                 await ui_events.emit(StatusFinished(status_id="agent:-1:progress"))
                 await ui_events.emit(StatusFinished(status_id="compaction"))
+                await ui_events.emit(TodoCleared())
                 await ui_events.emit(InputSet(text="", hints=[]))
                 await ui_events.drain()
             else:
+                dock.clear_todo_state()
                 dock.set_input("", [])
 
 

{voidx-2.1.1 → voidx-2.2.0}/src/voidx/agent/intent_refinement.py

@@ -72,7 +72,6 @@ def refine_intent(
         intent_refined=True,
     )
 
-    service = _skill_service(config, settings)
     return OnIntentResult(
         confirmed_intent=confirmed,
         confidence=inp.confidence,
@@ -82,7 +81,6 @@ def refine_intent(
         available_tool_ids=available_tool_ids,
         needs_user_confirmation=needs_confirmation,
         state_patch=patch,
-        skill_instructions=[service.render_instruction(match.skill) for match in matches],
     )
 
 
@@ -136,13 +134,14 @@ def _available_tools_for_intent(
         "lsp_definition",
         "lsp_references",
         "task_status",
+        "load_skills",
     }
     planning_tools = read_tools | {"agent", "todo", "bash"}
     implementation_tools = set(agent_tools)
     review_tools = read_tools | {"agent", "todo", "bash"}
 
     if intent in {TaskIntent.CHAT, TaskIntent.AMBIGUOUS}:
-        desired = set()
+        desired = {"load_skills"}
     elif intent == TaskIntent.INSPECT:
         desired = read_tools
     elif intent == TaskIntent.DESIGN:
@@ -205,14 +204,17 @@ def _skill_matches(
         agent=ctx.agent,
         task_intent=intent.value,
         interaction_mode=ctx.interaction_mode,
+        scopes=("bundled",),
+        exclude_names=ctx.active_skill_names,
     )
     seen = {normalize_skill_name(match.name) for match in matches}
+    excluded = {normalize_skill_name(name) for name in ctx.active_skill_names}
     for name in inp.suggested_skills:
         normalized = normalize_skill_name(name)
-        if normalized in seen:
+        if normalized in seen or normalized in excluded:
             continue
         skill = service.get(normalized)
-        if skill is None or not service.is_enabled(skill):
+        if skill is None or skill.meta.scope != "bundled" or not service.is_enabled(skill):
             continue
         matches.append(SkillMatch(skill=skill, reason="suggested"))
         seen.add(normalized)

{voidx-2.1.1 → voidx-2.2.0}/src/voidx/agent/runtime_context.py

@@ -9,12 +9,18 @@ import json
 import platform
 from typing import Any, Iterable
 
-from langchain_core.messages import BaseMessage, HumanMessage, SystemMessage
+from langchain_core.messages import BaseMessage, HumanMessage, SystemMessage, ToolMessage
 from pydantic import BaseModel, ConfigDict, Field
 
 from voidx.agent.message_rows import RowMessageCacheEntry
 from voidx.config import ApprovalReviewer, Config, UserProfile
 from voidx.runtime.intent import InteractionMode, TaskIntent, infer_task_intent
+from voidx.skills.context import (
+    has_skill_tool_context,
+    is_skill_context_content,
+    skill_context_cache_key,
+    strip_skill_tool_context,
+)
 from voidx.skills.runtime import SkillRunState
 
 _CONTEXT_MARKER = "VOIDX_RUNTIME_CONTEXT"
@@ -26,6 +32,9 @@ class ContextCompilerCache:
     stable_prefix_key: str = ""
     stable_system_content: str = ""
     stable_system_message: SystemMessage | None = None
+    skill_context_key: str = ""
+    skill_context_content: str = ""
+    skill_context_message: HumanMessage | None = None
     row_messages: dict[int, RowMessageCacheEntry] = dataclass_field(default_factory=dict)
 
 
@@ -68,11 +77,15 @@ class RuntimeContext(BaseModel):
 
     sections: list[ContextSection]
     task_sections: list[ContextSection] = Field(default_factory=list)
+    skill_context_content: str = ""
     system_content: str | None = None
     system_message: SystemMessage | None = Field(default=None, exclude=True)
+    skill_context_message: HumanMessage | None = Field(default=None, exclude=True)
 
     def section_names(self) -> list[str]:
         names = [section.name for section in self.sections]
+        if self.skill_context_content:
+            names.append("Skill Context")
         names.extend(section.name for section in self.task_sections)
         return names
 
@@ -97,6 +110,10 @@ class ContextCompiler:
     def compile_messages(self, messages: list[BaseMessage]) -> list[BaseMessage]:
         semantic_messages = raw_semantic_messages(messages)
         current_user_index = _last_user_index(semantic_messages)
+        semantic_messages = _strip_historical_tool_skill_context(
+            semantic_messages,
+            current_user_index,
+        )
 
         system_content = self.context.render_system()
         cached_system = self.context.system_message
@@ -113,11 +130,23 @@ class ContextCompiler:
                 current = semantic_messages[current_user_index]
                 semantic_messages[current_user_index] = _prepend_task_context(current, task_context)
 
-        return [prefix, *semantic_messages]
+        skill_context_message = self._skill_context_message()
+        if skill_context_message is None:
+            return [prefix, *semantic_messages]
+        return [prefix, skill_context_message, *semantic_messages]
 
     def apply_to_messages(self, messages: list[BaseMessage]) -> None:
         messages[:] = self.compile_messages(messages)
 
+    def _skill_context_message(self) -> HumanMessage | None:
+        content = self.context.skill_context_content.strip()
+        if not content:
+            return None
+        cached = self.context.skill_context_message
+        if cached is not None and cached.content == content:
+            return cached
+        return HumanMessage(content=content)
+
 
 class RuntimeContextBuilder:
     def __init__(
@@ -133,7 +162,7 @@ class RuntimeContextBuilder:
         agent: str,
         interaction_mode: str | InteractionMode,
         instructions: Iterable[str] = (),
-        skill_instructions: Iterable[str] = (),
+        skill_context_content: str = "",
         skill_runs: Iterable[SkillRunState] = (),
         active_skill_summaries: Iterable[str] = (),
         summary: str | None = None,
@@ -162,7 +191,7 @@ class RuntimeContextBuilder:
         self.agent = agent
         self.interaction_mode = InteractionMode.parse(interaction_mode)
         self.instructions = [item for item in instructions if item.strip()]
-        self.skill_instructions = [item for item in skill_instructions if item.strip()]
+        self.skill_context_content = skill_context_content.strip()
         self.skill_runs = list(skill_runs)
         self.active_skill_summaries = [item for item in active_skill_summaries if item.strip()]
         self.summary = summary.strip() if summary else ""
@@ -192,6 +221,12 @@ class RuntimeContextBuilder:
         return RuntimeContext(
             sections=self._build_stable_sections(),
             task_sections=self._build_task_sections(),
+            skill_context_content=self.skill_context_content,
+            skill_context_message=(
+                HumanMessage(content=self.skill_context_content)
+                if self.skill_context_content
+                else None
+            ),
         )
 
     def build_incremental(
@@ -213,13 +248,38 @@ class RuntimeContextBuilder:
             cache.stable_system_content = system_content
             cache.stable_system_message = system_message
 
+        skill_context_content, skill_context_message = self._incremental_skill_context(cache)
+
         return RuntimeContext(
             sections=sections,
             task_sections=self._build_task_sections(),
+            skill_context_content=skill_context_content,
             system_content=system_content,
             system_message=system_message,
+            skill_context_message=skill_context_message,
         ), cache
 
+    def _incremental_skill_context(
+        self,
+        cache: ContextCompilerCache,
+    ) -> tuple[str, HumanMessage | None]:
+        content = self.skill_context_content.strip()
+        if not content:
+            cache.skill_context_key = ""
+            cache.skill_context_content = ""
+            cache.skill_context_message = None
+            return "", None
+
+        key = skill_context_cache_key(content)
+        if cache.skill_context_key == key and cache.skill_context_content:
+            return cache.skill_context_content, cache.skill_context_message
+
+        message = HumanMessage(content=content)
+        cache.skill_context_key = key
+        cache.skill_context_content = content
+        cache.skill_context_message = message
+        return content, message
+
     def _build_stable_sections(self) -> list[ContextSection]:
         sections = [
             ContextSection(name="Base System", content=self.base_system_prompt),
@@ -266,11 +326,6 @@ class RuntimeContextBuilder:
             ContextSection(name="Runtime State", content=_render_envelope(envelope)),
             ContextSection(name="Current DateTime", content=self.current_datetime),
         ]
-        if self.skill_instructions:
-            task_sections.append(ContextSection(
-                name="Active Skills",
-                content="\n\n".join(self.skill_instructions),
-            ))
         task_sections.append(ContextSection(
             name="Current Task State",
             content=self._current_task_state(),
@@ -352,12 +407,33 @@ def raw_semantic_messages(messages: list[BaseMessage]) -> list[BaseMessage]:
         if isinstance(message, SystemMessage):
             continue
         if isinstance(message, HumanMessage):
+            if is_skill_context_content(message.content):
+                continue
             raw.append(_strip_turn_overlay(message))
         else:
             raw.append(message)
     return raw
 
 
+def _strip_historical_tool_skill_context(
+    messages: list[BaseMessage],
+    current_user_index: int | None,
+) -> list[BaseMessage]:
+    cutoff = current_user_index if current_user_index is not None else len(messages)
+    stripped: list[BaseMessage] = []
+    for index, message in enumerate(messages):
+        if index < cutoff and isinstance(message, ToolMessage):
+            if not has_skill_tool_context(message.content):
+                stripped.append(message)
+                continue
+            content = strip_skill_tool_context(message.content)
+            if content != message.content:
+                stripped.append(message.model_copy(update={"content": content}))
+                continue
+        stripped.append(message)
+    return stripped
+
+
 def _strip_turn_overlay(message: HumanMessage) -> HumanMessage:
     content = message.content
     if isinstance(content, str):