codee-agent 0.6.0__tar.gz → 0.6.2__tar.gz

{codee_agent-0.6.0 → codee_agent-0.6.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codee-agent
-Version: 0.6.0
+Version: 0.6.2
 Summary: A virtual co-worker that picks up Jira and Azure DevOps tasks and solves them with coding agents.
 Keywords: ai,agent,jira,azure-devops,claude-code,github-copilot,codex,automation
 Author: Denis Kibalko
@@ -41,6 +41,13 @@ Codee works with Jira and Azure DevOps as tasks providers, new providers are qui
 
 As agents it currently works with Claude Code, Github Copilot and Codex.
 
+## Documentation
+
+Full documentation is at [fusebase-dev.github.io/codee](https://fusebase-dev.github.io/codee/), covering
+installation, configuration and tutorials for working on tasks in Jira and Azure DevOps. There is also a
+[click-through demo of the admin UI](https://fusebase-dev.github.io/codee/demo/) that runs without installing
+anything.
+
 ## Run Codee
 
 Codee lives in its own directory, where it keeps skills, memory, temp files and config.

{codee_agent-0.6.0 → codee_agent-0.6.2}/README.md

@@ -6,6 +6,13 @@ Codee works with Jira and Azure DevOps as tasks providers, new providers are qui
 
 As agents it currently works with Claude Code, Github Copilot and Codex.
 
+## Documentation
+
+Full documentation is at [fusebase-dev.github.io/codee](https://fusebase-dev.github.io/codee/), covering
+installation, configuration and tutorials for working on tasks in Jira and Azure DevOps. There is also a
+[click-through demo of the admin UI](https://fusebase-dev.github.io/codee/demo/) that runs without installing
+anything.
+
 ## Run Codee
 
 Codee lives in its own directory, where it keeps skills, memory, temp files and config.

{codee_agent-0.6.0 → codee_agent-0.6.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "codee-agent"
-version = "0.6.0"
+version = "0.6.2"
 description = "A virtual co-worker that picks up Jira and Azure DevOps tasks and solves them with coding agents."
 readme = "README.md"
 license = "MIT"

{codee_agent-0.6.0 → codee_agent-0.6.2}/src/codee/admin.py

@@ -254,7 +254,10 @@ class RunRecord(BaseModel):
     status: str
     error: str
     started_at: str
+    session_id: str
     message: str
+    user_message: str
+    response: str
     preview: str
     viewer_url: str
 
@@ -798,7 +801,10 @@ class AdminState(rx.State):
                 status=run["status"],
                 error=run.get("error") or "",
                 started_at=run["started_at"],
+                session_id=run.get("session_id") or "",
                 message=message,
+                user_message=(run.get("user_message") or message).strip(),
+                response=(run.get("response") or "").strip(),
                 preview=preview[:120] + ("..." if len(preview) > 120 else ""),
                 viewer_url=(SERVICE.session_viewer.format(session_id=run["session_id"])
                             if SERVICE.session_viewer and run.get("session_id") else ""),
@@ -2386,6 +2392,9 @@ def run_row(run: RunRecord) -> rx.Component:
                                 rx.badge(run.status, color_scheme=rx.cond(run.status == "succeeded", "green", "red"))),
                       rx.text(run.started_at, color=MUTED, font_size="0.8rem",
                               font_family="IBM Plex Mono, monospace"),
+                          rx.text("Thread ID: ", run.session_id, color=MUTED,
+                              font_size="0.8rem",
+                              font_family="IBM Plex Mono, monospace"),
                       rx.text(run.preview, color=MUTED),
                       rx.cond(run.error != "", rx.text(
                           run.error, color="#b42318", font_size="0.85rem")),
@@ -2394,8 +2403,14 @@ def run_row(run: RunRecord) -> rx.Component:
             rx.cond(run.viewer_url != "", rx.link(rx.icon("external-link", size=16), href=run.viewer_url,
                                                   is_external=True, aria_label="View session", color=ACCENT)),
             gap="1rem", align="start", width="100%"),
-        rx.cond(run.message != "", rx.accordion.root(rx.accordion.item(
-            header="Full message", content=rx.text(run.message, white_space="pre-wrap"), value=run.started_at),
+        rx.cond((run.user_message != "") | (run.response != ""), rx.accordion.root(rx.accordion.item(
+            header="Run info", content=rx.vstack(
+                rx.text("User message", font_weight="600"),
+            rx.text(run.user_message, white_space="pre-wrap"),
+                rx.cond(run.response != "", rx.fragment(
+                    rx.text("LLM response", font_weight="600", margin_top="0.75rem"),
+                    rx.text(run.response, white_space="pre-wrap"))),
+                spacing="2", align="start", width="100%"), value=run.started_at),
             collapsible=True, width="100%")),
         padding="1rem", background=SURFACE, border=BORDER, width="100%")
 

{codee_agent-0.6.0 → codee_agent-0.6.2}/src/codee/executor.py

@@ -44,7 +44,8 @@ POLL_INTERVAL = 60  # 1 minute
 SESSIONS_FILE = context.data_dir / "sessions.json"
 # The project Codee operates on — same root the trigger modules scan for
 # `.claude/skills`. The coding agent is spawned with this as its cwd, so the
-# `/<slug>` messages we build from those skills actually resolve.
+# invocations we build from those skills — a `/<slug>` command, or a path to the
+# skill file for agents that don't resolve one — actually resolve.
 REPO_ROOT = project_root()
 
 # Task agents run concurrently, one thread each, so one long agent (up to 2h)
@@ -246,7 +247,7 @@ def _pull_latest_code() -> bool:
 
 
 def _run_agent(user_message: str, session_id: str, model: str = "",
-               agent_code: str = "") -> str:
+               agent_code: str = "", label: str = "") -> str:
     """Run the skill's coding agent and return its response text.
 
     ``model`` comes from the triggering skill's ``model:`` frontmatter; agents
@@ -254,9 +255,14 @@ def _run_agent(user_message: str, session_id: str, model: str = "",
     its ``x-codee-agent:`` frontmatter and picks which agent runs at all, empty
     for the default one. Wraps the agent run in job tracking; the agent itself
     raises on any failure so callers can retry.
+
+    ``label`` is how the run should read on the dashboard when that differs
+    from the prompt — an issue run is always shown as ``/<slug> <task id>``,
+    whatever wording the agent needed. Empty means the prompt is the label.
     """
     agent = _agent_for_skill(agent_code)
-    job_id = runs_db.start_job(session_id, user_message, agent=agent.DISPLAY_NAME,
+    job_id = runs_db.start_job(session_id, label or user_message,
+                               agent=agent.DISPLAY_NAME,
                                model=model, main_context=context)
     log.debug("job %s started: session=%s message=%r model=%r agent=%s",
               job_id, session_id, user_message, model, agent.describe())
@@ -288,21 +294,27 @@ def _run_agent(user_message: str, session_id: str, model: str = "",
 
 
 def _run_task(task_id: str, message: str, session_id: str, skill_name: str,
-              model: str = "", agent_code: str = "") -> None:
+              model: str = "", agent_code: str = "", label: str = "") -> None:
     """Pool worker: run one task's coding agent, then release its in-flight slot.
 
     Logs the outcome to the runs table like the cron/email/sqs triggers do, so
     issue-triggered coding runs show up on the dashboard too. Stamped with the
     launch time (not the finish time) so the hourly chart buckets it where it
     actually started — an agent can run for hours.
+
+    ``label`` is what the dashboard and the run log show instead of ``message``,
+    so every issue run reads as its ``/<slug> <task id>`` command no matter how
+    the agent had to be asked. The prompt itself is in the debug log.
     """
     started_at = datetime.now(timezone.utc).isoformat()
+    shown = label or message
     try:
-        response = _run_agent(message, session_id, model, agent_code)
+        response = _run_agent(message, session_id, model, agent_code, label)
         log.info("Agent response for %s (%d chars): %s",
                  task_id, len(response), response)
         runs_db.record_run(skill_name, "issue", session_id, "succeeded",
-                           started_at=started_at, message=message,
+                           started_at=started_at, message=shown,
+                           user_message=message, response=response,
                            main_context=context)
     except Exception as exc:
         # Over-limit / transient failure: leave the task in its current
@@ -311,14 +323,15 @@ def _run_task(task_id: str, message: str, session_id: str, skill_name: str,
         log.debug("%s failed with:\n%s", task_id, traceback.format_exc())
         runs_db.record_run(skill_name, "issue", session_id, "failed",
                            error=str(exc)[:500], started_at=started_at,
-                           message=message, main_context=context)
+                           message=shown, user_message=message,
+                           main_context=context)
     finally:
         with _inflight_lock:
             _inflight.discard(task_id)
 
 
 def _submit_task(task_id: str, message: str, session_id: str, skill_name: str,
-                 model: str = "", agent_code: str = "") -> bool:
+                 model: str = "", agent_code: str = "", label: str = "") -> bool:
     """Start a task's agent unless one is already in flight or we're at the cap.
 
     Returns True if launched, False if skipped — as a duplicate, or because
@@ -342,7 +355,7 @@ def _submit_task(task_id: str, message: str, session_id: str, skill_name: str,
     # killing it mid-run, which is what the thread pool used to give us.
     threading.Thread(target=_run_task, name=f"task-agent-{task_id}",
                      args=(task_id, message, session_id, skill_name, model,
-                           agent_code)).start()
+                           agent_code, label)).start()
     log.info("Started an agent for %s (%d running, max %d).",
              task_id, depth, limit)
     return True
@@ -424,13 +437,19 @@ def run_once() -> None:
             log.debug("No issue trigger matches %s (%s, %s); skipping",
                       task_id, status, issue_type)
             continue
-        message = f"/{skill.slug} {task_id}"
+        # How a skill is invoked is the agent's business: Claude Code resolves
+        # the slash command out of `.claude/skills`, Copilot has to be pointed
+        # at the file. The command stays the label either way, so one issue run
+        # reads the same on the dashboard whichever agent picked it up.
+        label = f"/{skill.slug} {task_id}"
+        message = _agent_for_skill(skill.agent).skill_prompt(
+            skill.slug, skill.path, task_id, skill.argument_name)
 
         log.info("Processing %s (%s, %s): %s  session-id=%s",
                  task_id, status, issue_type, summary, session_id)
 
         _submit_task(task_id, message, session_id, skill.name,
-                     skill.model, skill.agent)
+                     skill.model, skill.agent, label)
 
 
 def main() -> None:

{codee_agent-0.6.0 → codee_agent-0.6.2}/src/codee/lib/runs_db.py

@@ -11,7 +11,7 @@ from codee_main_context.context import CodeeMainContext
 from codee_database.database import get_db_connection
 
 _COLUMNS = ("id", "skill_name", "trigger_type", "session_id", "status", "error",
-            "started_at", "message")
+            "started_at", "message", "user_message", "response")
 
 # Codee names a session before the agent runs, but not every agent runs under
 # the name it was given: Codex mints its own thread id and reports it back mid
@@ -50,7 +50,9 @@ def init(main_context: CodeeMainContext) -> None:
                 status TEXT NOT NULL,
                 error TEXT,
                 started_at TEXT NOT NULL,
-                message TEXT
+                message TEXT,
+                user_message TEXT,
+                response TEXT
             )"""
         )
         conn.execute(
@@ -59,6 +61,10 @@ def init(main_context: CodeeMainContext) -> None:
         cols = {row[1] for row in conn.execute("PRAGMA table_info(runs)")}
         if "message" not in cols:
             conn.execute("ALTER TABLE runs ADD COLUMN message TEXT")
+        if "response" not in cols:
+            conn.execute("ALTER TABLE runs ADD COLUMN response TEXT")
+        if "user_message" not in cols:
+            conn.execute("ALTER TABLE runs ADD COLUMN user_message TEXT")
         # In-flight claude runs; a row lives only while its subprocess is running.
         conn.execute(
             """CREATE TABLE IF NOT EXISTS active_jobs (
@@ -78,7 +84,8 @@ def init(main_context: CodeeMainContext) -> None:
 
 
 def record_run(skill_name, trigger_type, session_id, status, error=None, started_at=None,
-               message=None, *, main_context: CodeeMainContext) -> None:
+               message=None, user_message=None, response=None,
+               *, main_context: CodeeMainContext) -> None:
     """Insert one run row. Never raises to the caller (FR-009)."""
     try:
         init(main_context)
@@ -88,9 +95,10 @@ def record_run(skill_name, trigger_type, session_id, status, error=None, started
         with get_db_connection(main_context) as conn:
             conn.execute(
                 "INSERT INTO runs (skill_name, trigger_type, session_id, status, error,"
-                " started_at, message) VALUES (?, ?, ?, ?, ?, ?, ?)",
+                " started_at, message, user_message, response)"
+                " VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)",
                 (skill_name, trigger_type, session_id,
-                 status, error, started_at, message),
+                 status, error, started_at, message, user_message, response),
             )
     except Exception as exc:  # ponytail: a logging miss must never abort the skill run
         print(f"[runs_db] Failed to record run for {skill_name}: {exc}")
@@ -104,7 +112,7 @@ def recent_runs(limit: int = 100, offset: int = 0, *,
         with get_db_connection(main_context) as conn:
             rows = conn.execute(
                 "SELECT id, skill_name, trigger_type, session_id, status, error,"
-                " started_at, message"
+                " started_at, message, user_message, response"
                 " FROM runs ORDER BY started_at DESC, id DESC LIMIT ? OFFSET ?",
                 (limit, max(offset, 0)),
             ).fetchall()

{codee_agent-0.6.0 → codee_agent-0.6.2}/src/codee/lib/test_runs_db.py

@@ -130,6 +130,17 @@ def test_message_round_trip(tmp_path):
     assert by_skill == {"a": "hello", "b": "", "c": None}
 
 
+def test_response_round_trip(tmp_path):
+    ctx = _ctx(tmp_path)
+    runs_db.record_run("a", "cron", "s1", "succeeded", message="question",
+                       user_message="full question", response="final answer",
+                       main_context=ctx)
+
+    run, = runs_db.recent_runs(main_context=ctx)
+    assert run["user_message"] == "full question"
+    assert run["response"] == "final answer"
+
+
 # ---------------------------------------------------------------- active_jobs
 def test_active_job_lifecycle(tmp_path):
     ctx = _ctx(tmp_path)
@@ -210,7 +221,7 @@ def test_fmt_elapsed():
     assert runs_db.fmt_elapsed(3700) == "1h 1m"
 
 
-def test_migration_adds_message_column_without_data_loss(tmp_path):
+def test_migration_adds_run_detail_columns_without_data_loss(tmp_path):
     ctx = _ctx(tmp_path)
     # Build an old-schema DB (spec 001, no message column) with one row.
     with sqlite3.connect(_db_file(tmp_path)) as conn:
@@ -231,10 +242,15 @@ def test_migration_adds_message_column_without_data_loss(tmp_path):
     assert len(rows) == 1
     assert rows[0]["skill_name"] == "old"
     assert rows[0]["message"] is None  # pre-feature row reads as NULL
-
-    # New writes carry message; the upgraded DB round-trips it.
-    runs_db.record_run("new", "cron", "sid-new", "succeeded", message="m", main_context=ctx)
-    assert runs_db.recent_runs(main_context=ctx)[0]["message"] == "m"
+    assert rows[0]["user_message"] is None
+    assert rows[0]["response"] is None
+
+    # New writes carry both details; the upgraded DB round-trips them.
+    runs_db.record_run("new", "cron", "sid-new", "succeeded", message="m",
+                       user_message="u", response="r", main_context=ctx)
+    newest = runs_db.recent_runs(main_context=ctx)[0]
+    assert (newest["message"], newest["user_message"], newest["response"]) == (
+        "m", "u", "r")
 
 
 # The agent Codee names a session for is not always the agent that runs under

{codee_agent-0.6.0 → codee_agent-0.6.2}/src/codee/lib/test_trigger_issue_skills.py

@@ -19,6 +19,27 @@ class IssueTriggeredSkillsTest(unittest.TestCase):
         directory.mkdir()
         (directory / "SKILL.md").write_text(f"---\n{frontmatter}---\nBody\n")
 
+    def test_reads_the_argument_name_out_of_the_argument_hint(self) -> None:
+        with tempfile.TemporaryDirectory() as temporary_directory:
+            root = Path(temporary_directory)
+            common = ("disable-model-invocation: true\nx-codee-trigger: issue\n"
+                      "x-codee-issue-status: [Ready]\nx-codee-issue-type: story\n")
+            self._skill(root, "bracketed",
+                        common + "argument-hint: <STORY_ID>\n")
+            self._skill(root, "bare", common + "argument-hint: STORY_ID\n")
+            self._skill(root, "several",
+                        common + "argument-hint: <TASK_ID> [continue]\n")
+            self._skill(root, "none", common)
+
+            names = {skill.slug: skill.argument_name
+                     for skill in find_issue_triggered_skills(root)}
+
+            self.assertEqual(names["bracketed"], "STORY_ID")
+            self.assertEqual(names["bare"], "STORY_ID")
+            # Only the first argument is passed; optional extras are dropped.
+            self.assertEqual(names["several"], "TASK_ID")
+            self.assertEqual(names["none"], "")
+
     def test_reads_the_model_frontmatter_when_present(self) -> None:
         with tempfile.TemporaryDirectory() as temporary_directory:
             root = Path(temporary_directory)

{codee_agent-0.6.0 → codee_agent-0.6.2}/src/codee/lib/trigger_aws_sqs_skills.py

@@ -80,11 +80,13 @@ def trigger_aws_sqs_skills(
             sqs_message_source.delete(message)
             runs_db.record_run(skill.name, "aws-sqs",
                                session_id, "succeeded", message=prompt,
+                               user_message=prompt, response=response,
                                main_context=main_context)
         except Exception as exc:
             print(f"[aws_sqs_skills] Failed to run {skill.name}: {exc}")
             runs_db.record_run(skill.name, "aws-sqs", session_id, "failed",
                                error=str(exc)[:500], message=prompt,
+                               user_message=prompt,
                                main_context=main_context)
 
 

{codee_agent-0.6.0 → codee_agent-0.6.2}/src/codee/lib/trigger_cron_skills.py

@@ -126,6 +126,7 @@ def trigger_cron_skills(
                 f"[cron_skills] Claude response for {skill.name} ({len(response)} chars)")
             runs_db.record_run(skill.name, "cron", session_id,
                                "succeeded", message=skill.body,
+                               user_message=skill.body, response=response,
                                main_context=main_context)
         except Exception as exc:
             # Don't advance the state slot: leave the job "due" so a later tick
@@ -135,6 +136,7 @@ def trigger_cron_skills(
                 f"[cron_skills] Failed to run {skill.name}, will retry: {exc}")
             runs_db.record_run(skill.name, "cron", session_id, "failed",
                                error=str(exc)[:500], message=skill.body,
+                               user_message=skill.body,
                                main_context=main_context)
             continue
         if is_forced:

{codee_agent-0.6.0 → codee_agent-0.6.2}/src/codee/lib/trigger_email_skills.py

@@ -89,12 +89,14 @@ def trigger_email_skills(
             path.unlink(missing_ok=True)
             runs_db.record_run(skill.name, "email", session_id,
                                "succeeded", message=prompt,
+                               user_message=prompt, response=response,
                                main_context=main_context)
         except Exception as exc:
             print(
                 f"[email_skills] Failed to run {skill.name} for {path.name}: {exc}")
             runs_db.record_run(skill.name, "email", session_id, "failed",
                                error=str(exc)[:500], message=prompt,
+                               user_message=prompt,
                                main_context=main_context)
 
 

{codee_agent-0.6.0 → codee_agent-0.6.2}/src/codee/lib/trigger_issue_skills.py

@@ -34,6 +34,10 @@ class IssueTriggeredSkill:
     # The agent this skill asks to be run by (``x-codee-agent``), empty when it
     # names none and the default agent from Settings should drive it.
     agent: str = ""
+    # What the skill calls the value it's invoked with (``argument-hint:
+    # <STORY_ID>``), empty when it names none. Agents that spell the invocation
+    # out instead of sending a slash command label the task id with it.
+    argument_name: str = ""
 
 
 def find_issue_triggered_skills(
@@ -91,6 +95,7 @@ def find_issue_triggered_skills(
             issue_type=issue_type,
             model=str(metadata.get("model", "")).strip(),
             agent=str(metadata.get("x-codee-agent", "") or "").strip(),
+            argument_name=_argument_name(metadata.get("argument-hint")),
         ))
     return skills
 
@@ -124,6 +129,18 @@ def _parse_frontmatter(contents: str) -> dict[str, Any]:
     return parsed if isinstance(parsed, dict) else {}
 
 
+def _argument_name(value: Any) -> str:
+    """The name a skill's ``argument-hint`` gives its first argument.
+
+    ``<STORY_ID>`` names ``STORY_ID`` and ``<TASK_ID> [continue]`` names
+    ``TASK_ID``: an issue trigger passes exactly one value, and that value is
+    the first the hint describes. Anything optional behind it is the skill's
+    own business and never reaches the invocation.
+    """
+    words = str(value or "").strip().split()
+    return words[0].strip("<>[]").strip() if words else ""
+
+
 def _status_values(value: Any) -> tuple[str, ...]:
     values = value if isinstance(value, list) else [value]
     return tuple(

{codee_agent-0.6.0 → codee_agent-0.6.2}/src/codee/test_executor.py

@@ -4,6 +4,7 @@ import unittest
 from pathlib import Path
 from unittest.mock import Mock, patch
 
+from codee_agent_claude_code.provider import ClaudeCodeAgent
 from codee_agent_codex.provider import CodexAgent
 from codee_agent_github_copilot.provider import GitHubCopilotAgent
 from codee_main_context.context import (
@@ -186,6 +187,33 @@ class AgentForSkillTest(unittest.TestCase):
                       executor.coding_agent)
 
 
+class SkillPromptTest(unittest.TestCase):
+    """The invocation a skill gets is phrased by the agent that will run it."""
+
+    SKILL = Path("/repo/.claude/skills/story-code-reviewer/SKILL.md")
+
+    def test_claude_code_gets_the_slash_command(self) -> None:
+        agent = ClaudeCodeAgent(Settings(), Path("/repo"))
+
+        self.assertEqual(
+            agent.skill_prompt("story-code-reviewer", self.SKILL, "90939",
+                               "STORY_ID"),
+            "/story-code-reviewer 90939",
+        )
+
+    def test_copilot_gets_told_to_read_the_skill_file(self) -> None:
+        # `copilot` resolves no slash command and the skill hides itself with
+        # disable-model-invocation, so the path has to be spelled out.
+        agent = GitHubCopilotAgent(Settings(), Path("/repo"))
+
+        self.assertEqual(
+            agent.skill_prompt("story-code-reviewer", self.SKILL, "90939",
+                               "STORY_ID"),
+            "Read .claude/skills/story-code-reviewer/SKILL.md and follow its "
+            "instructions exactly. STORY_ID = 90939",
+        )
+
+
 class RunAgentSelectionTest(unittest.TestCase):
     """The agent a run lands on is the one the triggering skill asked for."""
 
@@ -238,6 +266,8 @@ class RunTaskLoggingTest(unittest.TestCase):
         self.assertEqual(run["status"], "succeeded")
         self.assertEqual(run["session_id"], "sid-1")
         self.assertEqual(run["message"], "/story-developer NIM-1")
+        self.assertEqual(run["user_message"], "/story-developer NIM-1")
+        self.assertEqual(run["response"], "done")
 
     def test_failed_run_is_recorded_with_the_error(self) -> None:
         with patch.object(executor, "_run_agent", side_effect=RuntimeError("over limit")):
@@ -258,6 +288,49 @@ class RunTaskLoggingTest(unittest.TestCase):
             self.assertEqual(executor._run_agent("/story-developer NIM-4", "sid-4"),
                              "done")
 
+    def test_the_run_log_shows_the_command_not_the_agents_wording(self) -> None:
+        # A Copilot run is prompted with the skill's file path, but the run log
+        # is still the slash command, so both agents' runs read the same.
+        prompt = ("Read .claude/skills/story-developer/SKILL.md and follow its "
+                  "instructions exactly. STORY_ID = 4124")
+
+        with patch.object(executor, "_run_agent", return_value="done") as run:
+            executor._run_task("NIM-5", prompt, "sid-5", "story-developer",
+                               label="/story-developer 4124")
+
+        run_record, = self._runs()
+        self.assertEqual(run_record["message"], "/story-developer 4124")
+        self.assertEqual(run_record["user_message"], prompt)
+        # The agent still gets the wording it can act on.
+        self.assertEqual(run.call_args.args[0], prompt)
+
+    def test_a_failed_run_is_logged_under_the_command_too(self) -> None:
+        with patch.object(executor, "_run_agent", side_effect=RuntimeError("boom")):
+            executor._run_task("NIM-6", "Read .claude/skills/x/SKILL.md ...",
+                               "sid-6", "story-developer",
+                               label="/story-developer 4124")
+
+        run_record, = self._runs()
+        self.assertEqual(run_record["message"], "/story-developer 4124")
+
+    def test_the_live_job_row_carries_the_command(self) -> None:
+        with patch.object(executor.coding_agent, "run", return_value="done"), \
+                patch.object(runs_db, "start_job",
+                             return_value="job-1") as started:
+            executor._run_agent("Read .claude/skills/x/SKILL.md ...", "sid-7",
+                                label="/story-developer 4124")
+
+        self.assertEqual(started.call_args.args[1], "/story-developer 4124")
+
+    def test_a_run_with_no_label_is_shown_as_its_prompt(self) -> None:
+        # Cron, email and SQS hand over a skill body and have no command to show.
+        with patch.object(executor, "_run_agent", return_value="done"):
+            executor._run_task("NIM-7", "Do the nightly sweep", "sid-8",
+                               "nightly")
+
+        run_record, = self._runs()
+        self.assertEqual(run_record["message"], "Do the nightly sweep")
+
     def test_counts_include_issue_runs(self) -> None:
         with patch.object(executor, "_run_agent", return_value="done"):
             executor._run_task("NIM-3", "/story-developer NIM-3",

{codee_agent-0.6.0 → codee_agent-0.6.2}/src/codee_agent_abstract/provider.py

@@ -69,6 +69,21 @@ class AbstractCodingAgent(ABC):
         """
         ...
 
+    def skill_prompt(self, slug: str, path: Path, argument: str = "",
+                     argument_name: str = "") -> str:
+        """The message that makes this agent run the skill stored at ``path``.
+
+        The default is the slash command Claude Code resolves out of
+        ``.claude/skills``. Agents that don't read those skills — every
+        issue-triggered one carries ``disable-model-invocation: true``, so they
+        won't find it on their own either — override this and name the file.
+
+        ``argument`` is the single value the trigger passes (a task id) and
+        ``argument_name`` is what the skill's ``argument-hint`` calls it, empty
+        when it names none.
+        """
+        return f"/{slug} {argument}".strip()
+
     @classmethod
     def best_model(cls) -> str:
         """The id to pass for "the most capable model", for callers with no skill.

{codee_agent-0.6.0 → codee_agent-0.6.2}/src/codee_agent_github_copilot/provider.py

@@ -35,6 +35,10 @@ DEFAULT_MAX_AI_CREDITS = 1000
 # than a misconfigured cap, so a smaller override is raised to it instead.
 MIN_AI_CREDITS = 30
 
+# What to call the value an issue trigger passes when the skill's frontmatter
+# carries no ``argument-hint`` to name it.
+DEFAULT_ARGUMENT_NAME = "ARGUMENT"
+
 
 def _max_ai_credits() -> str:
     """The per-run credit cap, read fresh so a changed env applies to the next run."""
@@ -67,6 +71,22 @@ class GitHubCopilotAgent(AbstractCodingAgent):
     def best_model(cls) -> str:
         return cls.BEST_MODEL
 
+    def skill_prompt(self, slug: str, path: Path, argument: str = "",
+                     argument_name: str = "") -> str:
+        """Point copilot at the skill file instead of sending a slash command.
+
+        `copilot` has no slash command for `.claude/skills`, and every
+        issue-triggered skill sets ``disable-model-invocation: true``, so it
+        won't pick the skill up on its own either. Naming the file and telling
+        it to follow what's inside is the only way in. The path is relative to
+        the working directory the run gets, which is where the CLI starts.
+        """
+        prompt = (f"Read {_relative(path, self._cwd)} and follow its "
+                  "instructions exactly.")
+        if argument:
+            prompt += f" {argument_name or DEFAULT_ARGUMENT_NAME} = {argument}"
+        return prompt
+
     @classmethod
     def list_models(cls) -> list[AgentModel]:
         try:
@@ -149,6 +169,14 @@ class GitHubCopilotAgent(AbstractCodingAgent):
         return reply
 
 
+def _relative(path: Path, cwd: Path) -> str:
+    """``path`` as the CLI will see it from ``cwd``, or absolute if it's outside."""
+    try:
+        return str(path.relative_to(cwd))
+    except ValueError:
+        return str(path)
+
+
 def _fetch_acp_models() -> list[AgentModel]:
     """Ask ``copilot --acp`` for the account's model catalog.
 

{codee_agent-0.6.0 → codee_agent-0.6.2}/src/codee_agent_github_copilot/test.py

@@ -29,6 +29,51 @@ def _completed(stdout: str = "", stderr: str = "", returncode: int = 0):
         args=["copilot"], returncode=returncode, stdout=stdout, stderr=stderr)
 
 
+class CopilotSkillPromptTest(unittest.TestCase):
+    def setUp(self) -> None:
+        self.agent = GitHubCopilotAgent(Settings(), Path("/repo"))
+
+    def _prompt(self, path: Path, argument: str = "", argument_name: str = "") -> str:
+        return self.agent.skill_prompt("story-code-reviewer", path, argument,
+                                       argument_name)
+
+    def test_names_the_skill_file_instead_of_a_slash_command(self) -> None:
+        prompt = self._prompt(
+            Path("/repo/.claude/skills/story-code-reviewer/SKILL.md"),
+            "90939", "STORY_ID")
+
+        self.assertEqual(
+            prompt,
+            "Read .claude/skills/story-code-reviewer/SKILL.md and follow its "
+            "instructions exactly. STORY_ID = 90939",
+        )
+
+    def test_a_skill_that_names_no_argument_gets_a_generic_label(self) -> None:
+        prompt = self._prompt(
+            Path("/repo/.claude/skills/story-code-reviewer/SKILL.md"), "90939")
+
+        self.assertTrue(prompt.endswith("ARGUMENT = 90939"), prompt)
+
+    def test_no_argument_leaves_the_instruction_alone(self) -> None:
+        prompt = self._prompt(
+            Path("/repo/.claude/skills/story-code-reviewer/SKILL.md"))
+
+        self.assertEqual(
+            prompt,
+            "Read .claude/skills/story-code-reviewer/SKILL.md and follow its "
+            "instructions exactly.",
+        )
+
+    def test_a_skill_outside_the_working_directory_keeps_its_full_path(self) -> None:
+        prompt = self._prompt(Path("/elsewhere/skills/reviewer/SKILL.md"), "7", "ID")
+
+        self.assertEqual(
+            prompt,
+            "Read /elsewhere/skills/reviewer/SKILL.md and follow its "
+            "instructions exactly. ID = 7",
+        )
+
+
 class CopilotRunTest(unittest.TestCase):
     def setUp(self) -> None:
         self.agent = GitHubCopilotAgent(Settings(), Path("/repo"))