agentic-runner 2.6.1__tar.gz → 2.7.0__tar.gz

{agentic_runner-2.6.1 → agentic_runner-2.7.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: agentic-runner
-Version: 2.6.1
+Version: 2.7.0
 Summary: The Agentic OS Runner: an activity-only Temporal executor for workspaces, Agent Runtimes and verb seams
 License-Expression: AGPL-3.0-only
 License-File: LICENSE

{agentic_runner-2.6.1 → agentic_runner-2.7.0}/src/agentic_runner/__init__.py

@@ -7,6 +7,6 @@ stay on the platform; this package imports none of them, and a CI partition test
 (``tests/test_package_partition.py``) fails the build if that changes.
 """
 
-__version__ = "2.6.1"
+__version__ = "2.7.0"
 
 __all__ = ["__version__"]

{agentic_runner-2.6.1 → agentic_runner-2.7.0}/src/agentic_runner/activities.py

@@ -129,6 +129,14 @@ from agentic_runner.workers.fastapi_client import (
 )
 from agentic_runner.workers.harness_usage import extract_claude_result, extract_codex_turn_usage
 from agentic_runner.workers.mcp_config import McpServerEntry
+from agentic_runner.workers.skills import (
+    SkillDelivery,
+    delivery_for,
+    first_digest_mismatch,
+    remove_skills,
+    skills_preamble,
+    write_skills,
+)
 from agentic_runner_contracts.activity_io import (
     LEARNER_CHILDREN_BUDGET_BYTES,
     LEARNING_FAILED,
@@ -238,6 +246,7 @@ from agentic_runner_contracts.routing import (
 from agentic_runner_contracts.runtime_context import (
     EGRESS_ALLOW_LIST_KEY,
     McpServerSpec,
+    SkillVersionSpec,
     WorkerRuntimeContext,
     WorkerRuntimeContextResolver,
     work_branch_name,
@@ -491,6 +500,8 @@ class _RuntimeContextState:
     experience: str = ""
     experience_lesson_ids: tuple[str, ...] = ()
     experience_truncated: bool = False
+    # Console-v2 issue 28: the Skill versions attached to the Agent.
+    skills: tuple[SkillVersionSpec, ...] = ()
     workspace_path: Path | None = None
     branch_head_sha: str | None = None
     # The Autonomy Policy's tier source (PRD issue 14) -- see WorkerRuntimeContext for
@@ -533,6 +544,9 @@ class _DirectiveAttempt:
     # PRD issue 58: what config assembly wrote for the CLI, and where it may reach.
     mcp_servers: tuple[McpServerEntry, ...] | None = None
     egress_allow_list: tuple[str, ...] = ()
+    # Console-v2 issue 28: the attached Skills, for a runtime with no skills directory to
+    # write them into. Prefixed to the Directive prompt; empty when there is none.
+    skills_preamble: str = ""
 
     async def run_environment_hook(self) -> None:
         self.extra_env.update(await self.hooks.environment())
@@ -1325,6 +1339,7 @@ _ROUTING_EVIDENCE_SOURCE = "runner.routing"
 PRIOR_ATTEMPT_ALIVE_EVIDENCE_SOURCE = "runner.prior_attempt_alive"
 DIRECTIVE_TOKEN_EVIDENCE_SOURCE = "runner.directive_token"
 AGENT_RUNTIME_EVIDENCE_SOURCE = "runner.agent_runtime"
+SKILLS_EVIDENCE_SOURCE = "runner.skills"
 
 
 class _EvidenceWriter(Protocol):
@@ -1793,7 +1808,8 @@ class RunnerRalphActivities:
                     extra_env=attempt.env,
                     mcp_servers=attempt.mcp_servers,
                     egress_allow_list=attempt.egress_allow_list,
-                    prompt=_directive_prompt(
+                    prompt=attempt.skills_preamble
+                    + _directive_prompt(
                         completion_criteria=runtime_state.completion_criteria,
                         pr_body=request.pr_body,
                         persona_preamble=_persona_prompt_preamble(
@@ -2258,6 +2274,7 @@ class RunnerRalphActivities:
                 work_record_id, source=source, payload=dict(payload)
             )
 
+        await self._refuse_skill_digest_mismatch(work_record_id, state)
         credentials = await self._resolve_credentials(work_record_id, state)
         if credentials is not None:
             # Names only, at the moment they resolved (22 A1's Evidence): a support read
@@ -2321,6 +2338,13 @@ class RunnerRalphActivities:
                 credentials=credentials,
                 env=callback_env,
             )
+            delivered_preamble = await self._deliver_skills(
+                stack,
+                work_record_id=work_record_id,
+                state=state,
+                sandbox=sandbox,
+                directive_number=directive_number,
+            )
             session = await stack.enter_async_context(
                 DirectiveHookSession(
                     hooks=self._hooks,
@@ -2342,8 +2366,85 @@ class RunnerRalphActivities:
                 credentials=credentials,
                 mcp_servers=mcp_servers,
                 egress_allow_list=egress_allow_list,
+                skills_preamble=delivered_preamble,
             )
 
+    async def _refuse_skill_digest_mismatch(
+        self, work_record_id: str, state: _RuntimeContextState
+    ) -> None:
+        """A Skill whose body is not the version that was published fails the Directive
+        non-retryably (console-v2 issue 28): a retry would fetch the same body, and
+        running on it would hand the Agent prompt material no person reviewed."""
+
+        mismatch = first_digest_mismatch(state.skills)
+        if mismatch is None:
+            return
+        await _raise_recorded(
+            ApplicationError(
+                f"Skill {mismatch.slug} version {mismatch.version} does not match its sha256",
+                non_retryable=True,
+            ),
+            self._fastapi_client,
+            work_record_id,
+            source=SKILLS_EVIDENCE_SOURCE,
+            actor=self._actor(),
+            payload={
+                "event": "skills.digest_mismatch",
+                "agent_id": state.agent_id,
+                "slug": mismatch.slug,
+                "version": mismatch.version,
+                "sha256": mismatch.sha256,
+            },
+        )
+
+    async def _deliver_skills(
+        self,
+        stack: contextlib.AsyncExitStack,
+        *,
+        work_record_id: str,
+        state: _RuntimeContextState,
+        sandbox: DirectiveSandbox | None,
+        directive_number: int,
+    ) -> str:
+        """Put the attached Skills where this runtime reads them; return any preamble.
+
+        Written files are removed on the attempt's exit, success or failure. A Runner
+        with no Contract sandbox has no harness root it owns, so it falls back to the
+        preamble rather than writing into a shared ``CODEX_HOME``.
+        """
+
+        if not state.skills:
+            return ""
+        delivery = delivery_for(state.cli_kind)
+        if delivery is SkillDelivery.DIRECTORY and sandbox is None:
+            delivery = SkillDelivery.PROMPT_PREAMBLE
+        preamble = ""
+        if delivery is SkillDelivery.DIRECTORY:
+            assert sandbox is not None
+            # Registered before the write, so a write that fails half-way is cleaned too.
+            stack.push_async_callback(
+                remove_skills, sandbox.harness_config_dir, state.skills, uid=sandbox.uid
+            )
+            await write_skills(sandbox.harness_config_dir, state.skills, uid=sandbox.uid)
+        else:
+            preamble = skills_preamble(state.skills)
+        await self._fastapi_client.append_evidence(
+            work_record_id,
+            source=SKILLS_EVIDENCE_SOURCE,
+            payload={
+                "event": "skills.delivered",
+                "directive_number": directive_number,
+                "agent_id": state.agent_id,
+                "cli_kind": state.cli_kind,
+                "delivery": delivery.value,
+                "skills": [
+                    {"slug": skill.slug, "version": skill.version, "sha256": skill.sha256}
+                    for skill in state.skills
+                ],
+            },
+        )
+        return preamble
+
     async def _plan_mcp(
         self,
         work_record_id: str,
@@ -2995,6 +3096,7 @@ class RunnerRalphActivities:
             experience=runtime_context.experience,
             experience_lesson_ids=tuple(runtime_context.experience_lesson_ids),
             experience_truncated=runtime_context.experience_truncated,
+            skills=tuple(runtime_context.skills),
             workspace_path=resolved_workspace,
             branch_head_sha=branch_head_sha,
             product_id=runtime_context.product_id,
@@ -4253,7 +4355,8 @@ class RunnerRalphActivities:
                     extra_env=attempt.env,
                     mcp_servers=attempt.mcp_servers,
                     egress_allow_list=attempt.egress_allow_list,
-                    prompt=_learning_prompt(
+                    prompt=attempt.skills_preamble
+                    + _learning_prompt(
                         request,
                         base_branch=state.base_branch or request.base_ref,
                         transcript=self._learner_transcript(state, request.work_record_id),
@@ -4488,7 +4591,7 @@ class RunnerRalphActivities:
                     extra_env=attempt.env,
                     mcp_servers=attempt.mcp_servers,
                     egress_allow_list=attempt.egress_allow_list,
-                    prompt=await kind.prompt(state, prompt_notes),
+                    prompt=attempt.skills_preamble + await kind.prompt(state, prompt_notes),
                     base_branch=request.base_ref,
                     work_branch=state.work_branch,
                 )

agentic_runner-2.7.0/src/agentic_runner/workers/skills.py

@@ -0,0 +1,164 @@
+"""The Agent's attached Skills, delivered to its Agent Runtime for one Directive.
+
+Console-v2 issue 28, ADR-0017 §1. Where each runtime reads a Skill was measured against the
+Runner's own argv, not assumed (local-agents 02 asked the same question over ACP):
+
+- **Codex** (codex-cli 0.159.2): ``$CODEX_HOME/skills/<slug>/SKILL.md`` is advertised to the
+  model under ``codex exec``, with and without ``--ignore-user-config``. The Runner writes
+  there, in the Contract's harness root, and removes it after the Directive.
+- **Claude Code** (2.1.292): the Runner runs ``claude --print --bare``, and ``--bare`` drops
+  the Skill tool. ``$CLAUDE_CONFIG_DIR/skills/<slug>/SKILL.md`` is then neither advertised
+  nor resolved by ``/<slug>``, and ``--tools …,Skill`` does not bring the tool back. Claude
+  Code therefore gets the bodies as a prompt preamble. Dropping ``--bare`` would also
+  re-enable the Workspace's hooks and ``CLAUDE.md``, which is not this module's call.
+
+The harness root is per Contract, not per Directive, so two concurrent Directives of one
+Contract share its ``skills`` directory.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import hashlib
+import json
+import sys
+from collections.abc import Sequence
+from enum import StrEnum
+from pathlib import Path
+from typing import Final
+
+from agentic_runner_contracts.runtime_context import SkillVersionSpec
+
+__all__ = [
+    "SKILLS_DIR",
+    "SkillDelivery",
+    "SkillDeliveryError",
+    "delivery_for",
+    "first_digest_mismatch",
+    "remove_skills",
+    "skills_preamble",
+    "write_skills",
+]
+
+SKILLS_DIR: Final[str] = "skills"
+
+
+class SkillDelivery(StrEnum):
+    DIRECTORY = "directory"
+    PROMPT_PREAMBLE = "prompt_preamble"
+
+
+_DELIVERY_BY_CLI_KIND: Final[dict[str, SkillDelivery]] = {
+    "codex_cli": SkillDelivery.DIRECTORY,
+    "claude_code": SkillDelivery.PROMPT_PREAMBLE,
+}
+
+
+class SkillDeliveryError(RuntimeError):
+    """Raised when the Skills could not be written into, or removed from, the harness root."""
+
+
+def delivery_for(cli_kind: str) -> SkillDelivery:
+    return _DELIVERY_BY_CLI_KIND.get(cli_kind, SkillDelivery.PROMPT_PREAMBLE)
+
+
+def first_digest_mismatch(skills: Sequence[SkillVersionSpec]) -> SkillVersionSpec | None:
+    for skill in skills:
+        if hashlib.sha256(skill.body.encode("utf-8")).hexdigest() != skill.sha256:
+            return skill
+    return None
+
+
+def skills_preamble(skills: Sequence[SkillVersionSpec]) -> str:
+    """The bodies, for a runtime with no skills directory. Empty Skills, empty preamble,
+    so a Directive without Skills keeps a byte-identical prompt."""
+
+    if not skills:
+        return ""
+    sections = "".join(
+        f"Skill {skill.slug} (version {skill.version}):\n{skill.body.strip()}\n\n"
+        for skill in skills
+    )
+    return (
+        "The Skills below are attached to you. Follow each one where it applies.\n\n"
+        f"{sections}"
+        "The pipeline rules take precedence over the Skills above: edit files only, do not "
+        "run git commit or git push, and do not open a pull request — the pipeline commits, "
+        "pushes, and manages the PR.\n\n"
+    )
+
+
+# Both run as the Contract's uid, never the Runner's. The Contract owns its harness root, so
+# an Agent could have left a symlink there; a write or an rmtree by the Runner -- with
+# CAP_CHOWN and CAP_DAC_OVERRIDE -- would follow it out of the tree. As the Contract's uid
+# it can only reach what the Contract already could.
+_WRITE_SCRIPT: Final[str] = """
+import json, os, sys
+root, skills = json.load(sys.stdin)
+os.makedirs(root, mode=0o700, exist_ok=True)
+for slug, body in skills:
+    directory = os.path.join(root, slug)
+    os.makedirs(directory, mode=0o700, exist_ok=True)
+    path = os.path.join(directory, "SKILL.md")
+    flags = os.O_WRONLY | os.O_CREAT | os.O_TRUNC | os.O_NOFOLLOW
+    with os.fdopen(os.open(path, flags, 0o600), "w", encoding="utf-8") as handle:
+        handle.write(body)
+"""
+
+_REMOVE_SCRIPT: Final[str] = """
+import json, os, shutil, sys
+root, slugs = json.load(sys.stdin)
+for slug in slugs:
+    shutil.rmtree(os.path.join(root, slug), ignore_errors=True)
+left = [slug for slug in slugs if os.path.lexists(os.path.join(root, slug))]
+if left:
+    sys.exit("not removed: " + ", ".join(left))
+"""
+
+
+def _skills_root(harness_config_dir: Path) -> str:
+    return str(harness_config_dir / SKILLS_DIR)
+
+
+async def write_skills(
+    harness_config_dir: Path, skills: Sequence[SkillVersionSpec], *, uid: int | None
+) -> None:
+    """Write each Skill as ``<harness>/skills/<slug>/SKILL.md``, as the Contract's uid."""
+
+    await _run_as(
+        uid,
+        _WRITE_SCRIPT,
+        [_skills_root(harness_config_dir), [[skill.slug, skill.body] for skill in skills]],
+    )
+
+
+async def remove_skills(
+    harness_config_dir: Path, skills: Sequence[SkillVersionSpec], *, uid: int | None
+) -> None:
+    """Remove what :func:`write_skills` wrote. The ``skills`` directory itself stays:
+    Codex keeps its own ``.system`` Skills there."""
+
+    await _run_as(
+        uid,
+        _REMOVE_SCRIPT,
+        [_skills_root(harness_config_dir), [skill.slug for skill in skills]],
+    )
+
+
+async def _run_as(uid: int | None, script: str, payload: object) -> None:
+    identity: dict[str, object] = (
+        {} if uid is None else {"user": uid, "group": uid, "extra_groups": []}
+    )
+    process = await asyncio.create_subprocess_exec(
+        sys.executable,
+        "-I",
+        "-c",
+        script,
+        stdin=asyncio.subprocess.PIPE,
+        stdout=asyncio.subprocess.DEVNULL,
+        stderr=asyncio.subprocess.PIPE,
+        **identity,  # type: ignore[arg-type]
+    )
+    _, stderr = await process.communicate(json.dumps(payload).encode("utf-8"))
+    if process.returncode != 0:
+        raise SkillDeliveryError(stderr.decode("utf-8", errors="replace").strip()[-500:])