agentic-runner 3.16.2__tar.gz → 3.18.0__tar.gz

{agentic_runner-3.16.2 → agentic_runner-3.18.0}/PKG-INFO

@@ -1,11 +1,11 @@
 Metadata-Version: 2.5
 Name: agentic-runner
-Version: 3.16.2
+Version: 3.18.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
 Requires-Python: >=3.12
-Requires-Dist: agentic-runner-contracts==3.16.2
+Requires-Dist: agentic-runner-contracts==3.18.0
 Requires-Dist: cryptography<51,>=50
 Requires-Dist: httpx<1.0,>=0.27
 Requires-Dist: pydantic-settings<3.0,>=2.0

{agentic_runner-3.16.2 → agentic_runner-3.18.0}/pyproject.toml

@@ -10,7 +10,7 @@ dependencies = [
   # Exactly this release's contracts: the two ship as one version, and an unpinned
   # requirement let `uv tool upgrade` keep an older contracts wheel the Runner cannot
   # import from (QTS-1473). `scripts/set-version.py` moves it with the version.
-  "agentic-runner-contracts==3.16.2",
+  "agentic-runner-contracts==3.18.0",
   # Imported directly by `registration.py` (the Ed25519 identity that signs every
   # heartbeat); already present transitively through pyjwt[crypto], declared because
   # we import it.

{agentic_runner-3.16.2 → agentic_runner-3.18.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__ = "3.16.2"
+__version__ = "3.18.0"
 
 __all__ = ["__version__"]

{agentic_runner-3.16.2 → agentic_runner-3.18.0}/src/agentic_runner/activities.py

@@ -3888,7 +3888,7 @@ class RunnerRalphActivities:
                 "event": "directive.repository_refused",
                 "product_id": product_id,
                 "runner_id": str(self._routing_identity.runner_id),
-                "selector": dict(selector or {}),
+                "selector": [requirement.as_payload() for requirement in selector or ()],
             },
         )
 

{agentic_runner-3.16.2 → agentic_runner-3.18.0}/src/agentic_runner/cli.py

@@ -13,7 +13,8 @@ the Organisation's cap.
 
 ``install | start | stop | status <org>`` and ``credential set`` are the workstation
 Runner (PRD issue 47, ``workstation.py``): one login agent per Organisation, managed by
-the user who hosts it, with no ``sudo`` anywhere.
+the user who hosts it, with no ``sudo`` anywhere. ``add <name>`` registers another Runner
+beside them, reusing their control plane and ``PATH`` (ADR-0022 §21).
 
 ``sign-in --contract <id>`` signs one Contract's Claude Code in with Anthropic's own flow,
 in this terminal, as that Contract's uid in its harness root (QTS-1448). No code or token
@@ -179,6 +180,21 @@ def main(argv: Sequence[str] | None = None) -> int:
     )
     install.add_argument("--no-start", action="store_true", help="write the agent, do not start")
     install.add_argument("--root", default=None, type=Path, help="state root (default per OS)")
+
+    add = subcommands.add_parser(
+        "add",
+        help="register another Runner under this install, with its own process, identity "
+        "and Recipient Key (one per Contract)",
+    )
+    add.add_argument("org", metavar="name", help="the new Runner's name on this machine")
+    add.add_argument(
+        "--beside",
+        default=None,
+        help="the installed Runner whose control plane and PATH to reuse; needed only when "
+        "the installed Runners talk to different control planes",
+    )
+    add.add_argument("--no-start", action="store_true", help="write the agent, do not start")
+    add.add_argument("--root", default=None, type=Path, help="state root (default per OS)")
     for service_verb in ("start", "stop"):
         driven = subcommands.add_parser(
             service_verb, help=f"{service_verb} one Organisation's login agent"
@@ -312,7 +328,7 @@ def main(argv: Sequence[str] | None = None) -> int:
         if arguments.org:
             return workstation.run_process(_org_paths(arguments), login_agent=arguments.login_agent)
         return asyncio.run(service.run(attestation=_image_attestation()))
-    if arguments.command in {"install", "start", "stop", "credential"}:
+    if arguments.command in {"install", "add", "start", "stop", "credential"}:
         return _workstation(arguments)
     if arguments.command == "recipient-key":
         api, kube_ns = in_cluster()
@@ -359,6 +375,8 @@ def _workstation(arguments: argparse.Namespace) -> int:
     try:
         if arguments.command == "install":
             return _install(arguments, paths)
+        if arguments.command == "add":
+            return _add(arguments, paths)
         if arguments.command == "start":
             workstation.start(paths)
             print(f"started {paths.org}")
@@ -422,11 +440,7 @@ def _install(arguments: argparse.Namespace, paths: workstation.OrgPaths) -> int:
     except ValueError as error:
         print(str(error), file=sys.stderr)
         return 2
-    # Pasted, never a flag: a flag is in the process table for every uid on the box.
-    token = registration_token_from_env() or getpass.getpass(
-        "Runner Registration Token (yours from /me/runners, or the Organisation Admin's for "
-        "an Organisation Runner): "
-    )
+    token = _registration_token()
     settings = workstation.WorkstationSettings(
         org=paths.org,
         control_plane_url=arguments.control_plane,
@@ -436,11 +450,19 @@ def _install(arguments: argparse.Namespace, paths: workstation.OrgPaths) -> int:
         install_channel=workstation.install_channel(),
         acp_cli_kinds=acp_cli_kinds,
     )
+    return _register(paths, settings, token, start=not arguments.no_start)
+
+
+def _register(
+    paths: workstation.OrgPaths,
+    settings: workstation.WorkstationSettings,
+    token: str,
+    *,
+    start: bool,
+) -> int:
     try:
         lines = asyncio.run(
-            workstation.install(
-                paths, settings, registration_token=token, start_service=not arguments.no_start
-            )
+            workstation.install(paths, settings, registration_token=token, start_service=start)
         )
     except (workstation.CliMissingError, RunnerRegistrationError, RuntimeError) as error:
         print(f"install refused: {error}", file=sys.stderr)
@@ -450,6 +472,19 @@ def _install(arguments: argparse.Namespace, paths: workstation.OrgPaths) -> int:
     return 0
 
 
+def _add(arguments: argparse.Namespace, paths: workstation.OrgPaths) -> int:
+    settings = workstation.settings_to_add(paths, beside=arguments.beside)
+    return _register(paths, settings, _registration_token(), start=not arguments.no_start)
+
+
+def _registration_token() -> str:
+    # Pasted, never a flag: a flag is in the process table for every uid on the box.
+    return registration_token_from_env() or getpass.getpass(
+        "Runner Registration Token (yours from /me/runners, or the Organisation Admin's for "
+        "an Organisation Runner): "
+    )
+
+
 def _acp_cli_kinds(flag: str | None, paths: workstation.OrgPaths) -> str:
     # A reinstall to pick up a new PATH or retry a token must not turn ACP off (QTS-1355).
     if flag is not None:

{agentic_runner-3.16.2 → agentic_runner-3.18.0}/src/agentic_runner/registration.py

@@ -123,6 +123,9 @@ class RunnerState(BaseModel):
     # The control plane's cadence, as bootstrap told it (06 §4's 30 s by default); a
     # state file written before issue 47 carries none and keeps the default.
     heartbeat_interval_seconds: int = 30
+    # Where bootstrap said the namespace lives (ADR-0022 §4). Blank in a state file written
+    # before it, or from an older control plane: the process then uses `TEMPORAL_ADDRESS`.
+    temporal_address: str = ""
 
     def signer(self) -> Ed25519PrivateKey:
         key = serialization.load_pem_private_key(
@@ -279,6 +282,7 @@ class RunnerRegistrationClient:
             tags=dict(tags),
             max_concurrent_directives=max_concurrent_directives,
             heartbeat_interval_seconds=response.heartbeat_interval_seconds,
+            temporal_address=response.temporal_address,
         )
         return state, response
 

{agentic_runner-3.16.2 → agentic_runner-3.18.0}/src/agentic_runner/service.py

@@ -1112,6 +1112,14 @@ async def _serve(
         print(f"refusing to start ({error.reason}): {error}", flush=True)
         return 1
     print(outcome, flush=True)
+    temporal_address = state.temporal_address or settings.TEMPORAL_ADDRESS
+    if not temporal_address:
+        print(
+            "refusing to start (configuration_missing): the control plane gave no Temporal "
+            "address and TEMPORAL_ADDRESS is not set",
+            flush=True,
+        )
+        return 1
     interval = (
         heartbeat_interval if heartbeat_interval is not None else state.heartbeat_interval_seconds
     )
@@ -1125,6 +1133,7 @@ async def _serve(
             config=config,
             settings=settings,
             state=state,
+            temporal_address=temporal_address,
             mode=mode,
             can_change_uid=can_change_uid,
             control_plane=control_plane,
@@ -1148,6 +1157,7 @@ async def _serve_registered(
     config: RunnerConfig,
     settings: WorkerSettings,
     state: RunnerState,
+    temporal_address: str,
     mode: IsolationMode,
     can_change_uid: bool,
     control_plane: str,
@@ -1241,7 +1251,7 @@ async def _serve_registered(
             await asyncio.sleep(interval)
 
     client = await connect(
-        settings.TEMPORAL_ADDRESS,
+        temporal_address,
         namespace=state.temporal_namespace,
         api_key=stream.runner_token,
         tls=os.environ.get(TEMPORAL_TLS_ENV, "").strip().lower() in {"1", "true", "yes"},

{agentic_runner-3.16.2 → agentic_runner-3.18.0}/src/agentic_runner/testing/control_plane.py

@@ -167,6 +167,8 @@ class FakeControlPlane:
     contract_id: UUID = DEFAULT_CONTRACT_ID
     agent_id: UUID = DEFAULT_AGENT_ID
     cli_kind: str = "codex_cli"
+    # Blank answers as a control plane from before ADR-0022 §4 does: no address at all.
+    temporal_address: str = ""
 
     bootstraps: list[BootstrapRequest] = field(default_factory=list)
     runner_ids: list[UUID] = field(default_factory=list)
@@ -396,8 +398,14 @@ class FakeControlPlane:
             contracts_floor=self.contracts_floor,
             host_party=self.host_party,
             heartbeat_interval_seconds=self.heartbeat_interval_seconds,
+            temporal_address=self.temporal_address,
+        )
+        return _Answer(
+            200,
+            response.model_dump(
+                mode="json", exclude=None if self.temporal_address else {"temporal_address"}
+            ),
         )
-        return _Answer(200, response.model_dump(mode="json"))
 
     def _heartbeat(self, method: str, target: str, headers: dict[str, str], body: bytes) -> _Answer:
         runner_id, runner = self._signed(method, target, headers, body)

{agentic_runner-3.16.2 → agentic_runner-3.18.0}/src/agentic_runner/workers/settings.py

@@ -13,7 +13,13 @@ from agentic_runner_contracts.activity_io import DEFAULT_BUDGET, Budget
 class WorkerSettings(BaseSettings):
     """Runtime configuration for worker-only processes."""
 
-    TEMPORAL_ADDRESS: str = Field(..., description="Temporal server address in host:port format")
+    TEMPORAL_ADDRESS: str = Field(
+        default="",
+        description=(
+            "Temporal server address in host:port format. Only a fallback: the Runner uses "
+            "the address its registration response carries (ADR-0022 §4)."
+        ),
+    )
     TEMPORAL_NAMESPACE: str = Field(default="default", description="Temporal namespace name")
     PLATFORM_WORKER_SHARD_INDEX: int = Field(
         default=0,
@@ -216,6 +222,8 @@ class WorkerSettings(BaseSettings):
         """Validate host:port shape for Temporal server address."""
 
         stripped_value = value.strip()
+        if not stripped_value:
+            return stripped_value
         if stripped_value.count(":") < 1:
             raise ValueError("TEMPORAL_ADDRESS must follow host:port")
 

{agentic_runner-3.16.2 → agentic_runner-3.18.0}/src/agentic_runner/workstation.py

@@ -7,6 +7,8 @@ precedent does on a developer machine and nothing a daemon would need:
   identity, namespace, Runner Token, hooks, credential store and Workspaces under
   ``<root>/<org>/``. A contractor with two clients runs two. There is no supervisor over
   N Organisations -- that is the "one Runner straddling Organisations" 12 A6 rejected.
+  ``add <name>`` puts another such process beside them, a personal Runner per Contract
+  (ADR-0022 §21), named freely rather than after its Organisation.
 * **A login agent, never a system daemon** (23 item 1): a LaunchAgent in
   ``~/Library/LaunchAgents`` on macOS, a systemd *user* unit (with linger) on Linux, a
   per-user logon task on Windows. No ``sudo`` anywhere: the login keychain is unreachable
@@ -81,6 +83,7 @@ __all__ = [
     "run_environment",
     "run_process",
     "service_definition",
+    "settings_to_add",
     "start",
     "status_lines",
     "stop",
@@ -673,6 +676,50 @@ async def install(
     return lines
 
 
+def settings_to_add(paths: OrgPaths, *, beside: str | None) -> WorkstationSettings:
+    """``add <name>``: what ``install`` registers another Runner with (ADR-0022 §21).
+
+    A personal Runner serves one Contract, so a person with three Contracts runs three. Each
+    is ``install``'s own process with its own state directory -- identity, Runner Token and
+    Recipient Key (§37) -- and only the settings an earlier ``install`` was told are copied,
+    so the command the console shows carries no Temporal address.
+    """
+
+    # Registered state, not workstation.json: ``install`` saves the settings before it
+    # registers, so a refused token leaves them behind and the retry must go through.
+    if load_state(paths.state_dir) is not None:
+        raise ValueError(
+            f"{paths.org!r} is already installed under {paths.root}; pick a new name for "
+            "the Runner you are adding"
+        )
+    return _settings_beside(paths.root, beside).model_copy(update={"org": paths.org})
+
+
+def _settings_beside(root: Path, beside: str | None) -> WorkstationSettings:
+    if beside is not None:
+        return WorkstationSettings.load(OrgPaths(root=root, org=validate_org(beside)))
+    installed = [
+        WorkstationSettings.load(OrgPaths(root=root, org=file.parent.name))
+        for file in sorted(root.glob("*/workstation.json"), key=lambda file: file.stat().st_mtime)
+    ]
+    if not installed:
+        raise FileNotFoundError(
+            f"no Runner is installed under {root}; run `agentic-runner install` first"
+        )
+    endpoints = {
+        (settings.control_plane_url, settings.temporal_address, settings.temporal_tls)
+        for settings in installed
+    }
+    if len(endpoints) > 1:
+        names = ", ".join(sorted(settings.org for settings in installed))
+        raise ValueError(
+            f"the Runners under {root} ({names}) talk to different control planes; "
+            "name the one to add beside with --beside"
+        )
+    # The newest install's PATH and ACP kinds: the latest the person told this machine.
+    return installed[-1]
+
+
 def start(paths: OrgPaths, **driver: Any) -> None:
     _drive_service(paths, "start", **driver)