pilot-workers 0.5.2__tar.gz → 0.5.3__tar.gz

{pilot_workers-0.5.2/src/pilot_workers.egg-info → pilot_workers-0.5.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pilot-workers
-Version: 0.5.2
+Version: 0.5.3
 Summary: Dispatch bounded tasks to isolated LLM workers (GLM, Kimi, and more)
 License-Expression: MIT
 Requires-Python: >=3.11

{pilot_workers-0.5.2 → pilot_workers-0.5.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "pilot-workers"
-version = "0.5.2"
+version = "0.5.3"
 description = "Dispatch bounded tasks to isolated LLM workers (GLM, Kimi, and more)"
 readme = "README.md"
 license = "MIT"

{pilot_workers-0.5.2 → pilot_workers-0.5.3}/src/pilot_workers/cli/install.py

@@ -495,15 +495,52 @@ def apply_generated_region(skill_text: str, region: str) -> str:
     return before + GENERATED_BEGIN + inner + GENERATED_END + after
 
 
+def render_trigger_sentence(provider_keys: list[str],
+                            modes: dict[str, str]) -> str:
+    """The frontmatter's trigger clause, generated from the host's ROUTING.
+
+    This is the only part of the skill a model sees before deciding whether to
+    load it, so it decides what the whole feature can do. It used to read
+    "Trigger when the user names a worker provider — ds, kimi-k3", which is the
+    most specific clause in the description and therefore the operative one — so
+    "explore this codebase" never loaded the skill, and the mode -> provider table
+    (which lives in the BODY) was never read. The assignment recorded by
+    ``install ds on claude for explore`` was unreachable at trigger time: stored,
+    displayed by ``status``, rendered into the skill, and unable to fire.
+
+    The point of the assignment is that the user does NOT name a provider. So the
+    modes come first, in an explicit ``mode, mode -> provider`` form, and naming a
+    provider stays as an additional path. A host with no assignments routes
+    nothing and must not claim otherwise.
+    """
+    names = ", ".join(provider_keys)
+    routed: dict[str, list[str]] = {}
+    for mode, key in sorted(modes.items()):
+        if key in provider_keys:
+            routed.setdefault(key, []).append(mode)
+    if not routed:
+        return (f"No mode is routed on this host yet, so nothing is delegated "
+                f"automatically; naming a provider ({names}) triggers this skill.")
+    groups = "; ".join(
+        f"{', '.join(sorted(mode_list))} \u2192 {key}"
+        for key, mode_list in sorted(routed.items()))
+    return (f"Route by MODE, not by name: {groups}. A request for that kind of "
+            f"work triggers this skill even when the user names no provider — "
+            f"which is the point of the routing — and naming one ({names}) "
+            f"triggers it too.")
+
+
 def substitute_trigger_placeholder(skill_text: str,
-                                   provider_keys: list[str]) -> str:
-    """Fill the frontmatter trigger token with the host's provider keys.
+                                   provider_keys: list[str],
+                                   modes: dict[str, str] | None = None) -> str:
+    """Fill the frontmatter trigger token.
 
     Pure string function: a host's deployed skill names exactly the providers
     configured for it, so "use <provider>" reaches the skill without leaking
     the names of providers the host never got.
     """
-    return skill_text.replace(TRIGGER_PLACEHOLDER, ", ".join(provider_keys))
+    return skill_text.replace(
+        TRIGGER_PLACEHOLDER, render_trigger_sentence(provider_keys, modes or {}))
 
 
 def _frontmatter_block(text: str) -> str | None:
@@ -537,7 +574,8 @@ def _render_deployed_skill(installs: dict, host: str, base_text: str) -> str:
     could never drop a provider that was uninstalled later.
     """
     provider_keys = host_providers(installs, host)
-    region = render_worker_region(provider_keys, host_modes(installs, host))
+    modes = host_modes(installs, host)
+    region = render_worker_region(provider_keys, modes)
     try:
         out = apply_generated_region(base_text, region)
     except RuntimeError:
@@ -551,7 +589,7 @@ def _render_deployed_skill(installs: dict, host: str, base_text: str) -> str:
         out = apply_generated_region(_packaged_skill_text(host), region)
     new_front = _frontmatter_block(
         substitute_trigger_placeholder(_packaged_skill_text(host),
-                                       provider_keys))
+                                       provider_keys, modes))
     old_front = _frontmatter_block(out)
     if new_front is not None and old_front is not None:
         out = new_front + out[len(old_front):]

{pilot_workers-0.5.2 → pilot_workers-0.5.3}/src/pilot_workers/integrations/claude-host/skills/pilot-workers/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: pilot-workers
-description: Dispatch bounded tasks (code, explore, test, review, resume) to isolated LLM workers via the pilot-workers CLI and harvest their structured verdicts. Use whenever a task is worth delegating — bulk mechanical edits, codebase exploration, long test runs, multi-axis code review — so the main session keeps its context for planning and verification. Not for small tweaks, tasks needing mid-course judgment, or anything touching credentials/CI/production. Trigger when the user names a worker provider — {{PILOT_PROVIDER_TRIGGERS}}.
+description: Dispatch bounded tasks (code, explore, test, review, resume) to isolated LLM workers via the pilot-workers CLI and harvest their structured verdicts. Use whenever a task is worth delegating — bulk mechanical edits, codebase exploration, long test runs, multi-axis code review — so the main session keeps its context for planning and verification. Not for small tweaks, tasks needing mid-course judgment, or anything touching credentials/CI/production. {{PILOT_PROVIDER_TRIGGERS}}
 ---
 
 # pilot-workers Playbook

{pilot_workers-0.5.2 → pilot_workers-0.5.3}/src/pilot_workers/integrations/codex-host/skills/pilot-workers/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: pilot-workers
-description: Plan with Codex, then run bounded tasks (code, explore, test, review, resume) through isolated LLM workers via the pilot-workers CLI and verify their structured verdicts. Invoke explicitly as `$pilot-workers [code|explore|test|review|resume] [task]`. Use whenever the user asks to delegate coding, investigation, testing, review, or session continuation to a worker model — {{PILOT_PROVIDER_TRIGGERS}}. Not for small tweaks, mid-course judgment calls, or credentials/CI/production changes.
+description: Plan with Codex, then run bounded tasks (code, explore, test, review, resume) through isolated LLM workers via the pilot-workers CLI and verify their structured verdicts. Invoke explicitly as `$pilot-workers [code|explore|test|review|resume] [task]`. Use whenever coding, investigation, testing, review or session continuation is worth handing to a worker model. {{PILOT_PROVIDER_TRIGGERS}} Not for small tweaks, mid-course judgment calls, or credentials/CI/production changes.
 ---
 
 # pilot-workers Playbook

{pilot_workers-0.5.2 → pilot_workers-0.5.3/src/pilot_workers.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pilot-workers
-Version: 0.5.2
+Version: 0.5.3
 Summary: Dispatch bounded tasks to isolated LLM workers (GLM, Kimi, and more)
 License-Expression: MIT
 Requires-Python: >=3.11

{pilot_workers-0.5.2 → pilot_workers-0.5.3}/tests/test_integrations.py

@@ -150,3 +150,33 @@ def test_common_prompt_exists_and_has_no_result_block():
     assert RESULT_END not in text, (
         "common.md must not contain the result block (it is per-mode)"
     )
+
+
+def test_no_host_template_hardcodes_its_own_trigger_condition():
+    """Both templates must hand the whole trigger clause to the placeholder.
+
+    The clause is generated from the host's routing, so any wording left in the
+    template competes with it — and the first pass at this fix patched the claude
+    template and missed the codex one, which phrased the same sentence
+    differently. Sibling-miss number twelve; the guard costs four lines.
+    """
+    from pathlib import Path as _Path
+
+    import pilot_workers
+    from pilot_workers.cli import install as install_mod
+
+    root = _Path(pilot_workers.__file__).resolve().parent / "integrations"
+    offenders = []
+    for host in ("claude", "codex"):
+        path = root / f"{host}-host" / "skills" / "pilot-workers" / "SKILL.md"
+        front = install_mod._frontmatter_block(
+            path.read_text(encoding="utf-8")) or ""
+        normalised = " ".join(front.split())
+        assert install_mod.TRIGGER_PLACEHOLDER in normalised, (
+            f"{host}: the template lost its trigger placeholder")
+        for phrase in ("Trigger when the user names",
+                       "asks to delegate",
+                       "to a worker model —"):
+            if phrase in normalised:
+                offenders.append(f"{host}: still hardcodes {phrase!r}")
+    assert not offenders, "; ".join(offenders)

{pilot_workers-0.5.2 → pilot_workers-0.5.3}/tests/test_skill_generation.py

@@ -1177,3 +1177,92 @@ def test_a_file_dropped_from_the_packaged_tree_stops_being_deployed(isolated, ca
     recorded = json.loads(manifest_path.read_text(encoding="utf-8"))
     assert str(stale) not in recorded["installs"]["claude"]["files"]
     assert "removed stale" in capsys.readouterr().out
+
+
+# ----------------------------------------------------------------------
+# The trigger must fire on the WORK, not on a provider name.
+#
+# The whole point of `install ds on claude for explore` is that the user says
+# "explore this codebase" and the system picks ds. The generated description
+# ended with "Trigger when the user names a worker provider — ds, kimi-k3",
+# which is the most specific clause in it and therefore the operative one, so a
+# prompt that named no provider never loaded the skill — and the mode -> provider
+# table lives in the BODY, readable only after loading. The assignment was
+# unreachable at trigger time: recorded, displayed by `status`, rendered into the
+# skill, and never able to fire.
+# ----------------------------------------------------------------------
+
+def _deployed_description(isolated, providers_and_modes):
+    """Install a host with the given config and return its rendered description."""
+    with install_mod.manifest_transaction() as installs:
+        for key in providers_and_modes["providers"]:
+            install_mod.add_host_provider(installs, "claude", key)
+        for mode, key in providers_and_modes["modes"].items():
+            install_mod.set_host_mode(installs, "claude", mode, key)
+    install_mod.main(["claude", "--target", str(isolated["target"])])
+    text = _claude_skill(isolated).read_text(encoding="utf-8")
+    front = install_mod._frontmatter_block(text)
+    assert front is not None
+    return " ".join(front.split())
+
+
+def test_the_description_triggers_on_an_assigned_mode(isolated):
+    """A prompt like "explore this codebase" must be able to match.
+
+    Asserted on the exact ROUTING form, not on the mode word: the description's
+    first sentence already lists every mode ("bounded tasks (code, explore,
+    test, review, resume)"), so a substring check for "explore" passes whatever
+    the trigger says. The first version of this test did exactly that and passed
+    against the broken description.
+    """
+    description = _deployed_description(isolated, {
+        "providers": ["ds", "kimi-k3"],
+        "modes": {"explore": "ds", "test": "ds",
+                  "code": "kimi-k3", "review": "kimi-k3"},
+    })
+    assert "explore, test → ds" in description, description
+    assert "code, review → kimi-k3" in description, description
+
+
+def test_the_description_no_longer_makes_a_provider_name_the_condition(isolated):
+    """The narrowing sentence that defeated the whole feature must be gone."""
+    description = _deployed_description(isolated, {
+        "providers": ["ds"], "modes": {"explore": "ds"},
+    })
+    assert "Trigger when the user names a worker provider" not in description, (
+        "the operative clause still requires the user to name a provider")
+
+
+def test_naming_a_provider_directly_still_triggers(isolated):
+    """The old path must survive: "use ds to ..." is still a valid way in."""
+    description = _deployed_description(isolated, {
+        "providers": ["ds"], "modes": {"explore": "ds"},
+    })
+    assert "ds" in description
+
+
+def test_a_host_with_no_mode_assignments_does_not_claim_mode_triggering(isolated):
+    """Nothing is routed, so the skill must not advertise that it handles a mode."""
+    description = _deployed_description(isolated, {
+        "providers": ["ds"], "modes": {},
+    })
+    assert "ds" in description
+    for mode in ("explore", "test", "review"):
+        assert f"{mode} →" not in description and f"{mode} ->" not in description, (
+            f"a host with no assignments claims to route {mode}")
+
+
+def test_an_unassigned_mode_is_not_advertised(isolated):
+    """Only what is actually routed. `code` has no provider here."""
+    description = _deployed_description(isolated, {
+        "providers": ["ds"], "modes": {"explore": "ds"},
+    })
+    routing = install_mod.render_trigger_sentence(["ds"], {"explore": "ds"})
+    assert "explore → ds" in routing
+    # Scoped to the GENERATED clause: the hand-written prose above it legitimately
+    # mentions "bulk mechanical edits" as an example of delegable work, so a check
+    # against the whole description flagged text that was never the problem.
+    for mode in ("code", "review", "test"):
+        assert f"{mode} →" not in routing, (
+            f"the routing clause advertises {mode}, which nothing is assigned to")
+    assert "explore → ds" in description, description