agentic-runner 3.12.2__tar.gz → 3.14.0__tar.gz

{agentic_runner-3.12.2 → agentic_runner-3.14.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: agentic-runner
-Version: 3.12.2
+Version: 3.14.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-3.12.2 → agentic_runner-3.14.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.12.2"
+__version__ = "3.14.0"
 
 __all__ = ["__version__"]

{agentic_runner-3.12.2 → agentic_runner-3.14.0}/src/agentic_runner/cli.py

@@ -15,6 +15,13 @@ the Organisation's cap.
 Runner (PRD issue 47, ``workstation.py``): one login agent per Organisation, managed by
 the user who hosts it, with no ``sudo`` anywhere.
 
+``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
+passes through the control plane.
+
+``skill install | print`` hands the setup skill to the person's own Claude Code or Codex
+(``skill.py``, console-v2 issue 21).
+
 The remaining subcommands are what a Directive calls back with, over its own attempt
 socket (``callback.py``): ``annotate``, ``artifact upload``, ``verb`` and ``message send |
 list`` (the Channel seam, PRD issue 52) and ``ask`` (a Question, issue 60). They read the
@@ -33,9 +40,10 @@ import os
 import sys
 from collections.abc import Sequence
 from pathlib import Path
+from uuid import UUID
 
 from agentic_runner import __version__ as runner_version
-from agentic_runner import service, workstation
+from agentic_runner import service, skill, workstation
 from agentic_runner.callback import (
     CALLBACK_SOCKET_ENV,
     CALLBACK_TOKEN_ENV,
@@ -56,6 +64,7 @@ from agentic_runner.service import (
     TAGS_ENV,
     parse_tags,
 )
+from agentic_runner.workers.claude_sign_in import OAUTH_TOKEN, SIGN_IN_METHODS
 from agentic_runner_contracts import __version__ as contracts_version
 from agentic_runner_contracts.runner_registration import (
     HostAttestation,
@@ -195,6 +204,21 @@ def main(argv: Sequence[str] | None = None) -> int:
     status.add_argument("org", nargs="?", help="a workstation Organisation (issue 47)")
     status.add_argument("--root", default=None, type=Path)
 
+    sign_in = subcommands.add_parser(
+        "sign-in",
+        help="sign a Contract's Claude Code in with Anthropic's own flow, in this terminal",
+    )
+    sign_in.add_argument("--contract", required=True, help="the Contract's id")
+    sign_in.add_argument(
+        "--method",
+        default=OAUTH_TOKEN,
+        choices=SIGN_IN_METHODS,
+        help="oauth_token: a long-lived token (claude setup-token); claude_ai: a Claude.ai "
+        "login (claude auth login --claudeai)",
+    )
+    sign_in.add_argument("--org", default=None, help="a workstation Organisation (issue 47)")
+    sign_in.add_argument("--root", default=None, type=Path, help=argparse.SUPPRESS)
+
     annotate = subcommands.add_parser("annotate", help="attach an annotation to this Work Record")
     annotate.add_argument("--context", default="default")
     annotate.add_argument(
@@ -250,6 +274,18 @@ def main(argv: Sequence[str] | None = None) -> int:
         "--base", default="", help="`branch` only: the base branch; default the repository's"
     )
 
+    skill_parser = subcommands.add_parser(
+        "skill", help="the setup skill for your own Claude Code or Codex (console-v2 issue 21)"
+    )
+    skill_parser.add_argument("action", choices=("install", "print"))
+    only = skill_parser.add_mutually_exclusive_group()
+    only.add_argument(
+        "--claude", dest="targets", action="store_const", const=("claude",), help="Claude only"
+    )
+    only.add_argument(
+        "--codex", dest="targets", action="store_const", const=("codex",), help="Codex only"
+    )
+
     subcommands.add_parser("config", help="print the resolved configuration (flag > env > file)")
 
     arguments = parser.parse_args(argv)
@@ -288,6 +324,15 @@ def main(argv: Sequence[str] | None = None) -> int:
         for line in lines:
             print(line)
         return 0
+    if arguments.command == "sign-in":
+        return _sign_in(arguments)
+    if arguments.command == "skill":
+        if arguments.action == "print":
+            sys.stdout.write(skill.text())
+            return 0
+        for path in skill.install(arguments.targets or skill.TARGETS):
+            print(f"installed {path}")
+        return 0
     if arguments.command == "config":
         config = load_config(config_file=arguments.config, hooks_path=arguments.hooks_path)
         print(config.model_dump_json(indent=2))
@@ -344,6 +389,26 @@ def _image_attestation() -> HostAttestation:
     )
 
 
+def _sign_in(arguments: argparse.Namespace) -> int:
+    try:
+        contract_id = str(UUID(arguments.contract))
+    except ValueError:
+        print(f"--contract expects a Contract id, got {arguments.contract!r}", file=sys.stderr)
+        return 2
+    if not (os.isatty(0) and os.isatty(1)):
+        print(
+            "sign-in is interactive: run it in a terminal (`kubectl exec -it`, `docker exec -it`)",
+            file=sys.stderr,
+        )
+        return 2
+    if arguments.org:
+        paths = _org_paths(arguments)
+        os.environ.update(
+            workstation.run_environment(paths, workstation.WorkstationSettings.load(paths))
+        )
+    return asyncio.run(service.sign_in_claude(contract_id, method=arguments.method))
+
+
 def _install(arguments: argparse.Namespace, paths: workstation.OrgPaths) -> int:
     if not arguments.control_plane:
         print(f"--control-plane (or {CONTROL_PLANE_ENV}) is required", file=sys.stderr)

{agentic_runner-3.12.2 → agentic_runner-3.14.0}/src/agentic_runner/device_login_activities.py

@@ -14,7 +14,6 @@ from temporalio import activity
 from temporalio.exceptions import ApplicationError
 
 from agentic_runner.auth_mode import SHARED_RUNNER_SIGN_IN_RULE, is_shared_runner
-from agentic_runner.workers.claude_sign_in import OAUTH_TOKEN
 from agentic_runner.workers.contract_device_login import ContractDeviceLogin
 from agentic_runner.workers.contract_isolation import ContractIsolation
 from agentic_runner_contracts.activity_io import (
@@ -37,8 +36,9 @@ class ContractDeviceLoginActivities:
         host_party: str | None = None,
     ) -> None:
         self._contract_isolation = contract_isolation
-        # The party this process was registered as hosted by. A shared Runner signs in only
-        # a Claude Code long-lived token (local-agents 04, amended by 21).
+        # The party this process was registered as hosted by. A shared Runner starts no
+        # device login and reports only Claude Code's sign-in (local-agents 04, amended by
+        # 21); a person signs Claude Code in on the Runner itself (QTS-1448).
         self._host_party = host_party
         # Injectable for tests; None falls through to the real vendor CLIs.
         self._device_login = device_login or ContractDeviceLogin(contract_isolation)
@@ -53,12 +53,9 @@ class ContractDeviceLoginActivities:
     async def sign_in_contract_device_login(
         self, request: ContractDeviceLoginInput
     ) -> ContractDeviceLoginResult:
-        long_lived = request.runtime_kind == "claude_code" and (request.method or OAUTH_TOKEN) == (
-            OAUTH_TOKEN
-        )
-        self._refuse_on_shared_runner(allow=long_lived)
+        self._refuse_on_shared_runner()
         prompt = await self._device_login.sign_in(
-            request.contract_id, runtime_kind=request.runtime_kind, method=request.method
+            request.contract_id, runtime_kind=request.runtime_kind
         )
         return ContractDeviceLoginResult(
             contract_id=prompt.contract_id,
@@ -66,7 +63,6 @@ class ContractDeviceLoginActivities:
             verification_uri=prompt.verification_uri,
             user_code=prompt.user_code,
             expires_at=prompt.expires_at.isoformat(),
-            sign_in_id=prompt.sign_in_id,
         )
 
     @activity.defn(name="check_contract_device_login_status")
@@ -107,7 +103,7 @@ class ContractDeviceLoginActivities:
         on here, so the failure the platform's sign-in workflow receives names it.
 
         Only a Runner known to be the person's own signs in, except that a shared Runner
-        may make (``allow``) a Claude Code long-lived token (local-agents 21). One whose
+        may report (``allow``) a Claude Code long-lived token (local-agents 21). One whose
         state names no host party (registered before issue 42) is refused either way, as
         `choose_auth_mode` never runs a subscription on it."""
 

{agentic_runner-3.12.2 → agentic_runner-3.14.0}/src/agentic_runner/sealed_box.py

@@ -63,7 +63,6 @@ from agentic_runner_contracts.sealed_credential import (
     SEAL_DOMAIN,
     OpenedCredential,
     SealedCredential,
-    SealedSignInCode,
     delivery_binding,
     key_fingerprint,
 )
@@ -554,20 +553,10 @@ class SealedCredentialStream:
         if not self._awaiting:
             self._keys.retire_previous()
 
-    def open_sign_in_code(self, sealed: SealedSignInCode) -> str | None:
-        """A relayed sign-in code, or None when it does not open (local-agents 05).
-
-        Opened with the same Recipient Key as a slot, but never held: the caller types it
-        into the waiting CLI and drops it.
-        """
-
-        return self._open_with(sealed.recipient_key_id, sealed.binding(), sealed.ciphertext)
-
     def open_oauth_code(self, sealed: SealedOAuthCode) -> str | None:
         """A relayed OAuth code, or None when it does not open (console-v2 issue 30).
 
-        Never held, like a sign-in code: the caller spends it on the token endpoint and
-        drops it.
+        Never held: the caller spends it on the token endpoint and drops it.
         """
 
         return self._open_with(sealed.recipient_key_id, sealed.binding(), sealed.ciphertext)

{agentic_runner-3.12.2 → agentic_runner-3.14.0}/src/agentic_runner/service.py

@@ -24,6 +24,7 @@ import logging
 import os
 import shutil
 import signal
+import sys
 import tempfile
 import time
 from collections.abc import Awaitable, Callable, Mapping, Sequence
@@ -34,6 +35,7 @@ from typing import Any, Protocol
 from uuid import UUID
 
 import httpx
+from pydantic import ValidationError
 from temporalio import activity
 from temporalio.client import Client
 from temporalio.worker import (
@@ -110,7 +112,7 @@ from agentic_runner.user_sources import ProxyTriage, UserSourcePoller
 from agentic_runner.workers.acp_runtime import ACP_BRIDGES, AcpRuntime, profile_acp_executables
 from agentic_runner.workers.agent_runtime import AgentRuntime
 from agentic_runner.workers.claude_runtime import ClaudeRuntime
-from agentic_runner.workers.claude_sign_in import ClaudeSignIns
+from agentic_runner.workers.claude_sign_in import ClaudeSignInError, ClaudeSignIns
 from agentic_runner.workers.codex_runtime import CodexRuntime
 from agentic_runner.workers.contract_device_login import ContractDeviceLogin
 from agentic_runner.workers.contract_isolation import UID_MAP_FILENAME, ContractIsolation
@@ -135,11 +137,7 @@ from agentic_runner_contracts.runner_registration import (
     ResourcePressure,
 )
 from agentic_runner_contracts.runtime_context import WorkerRuntimeContextResolver
-from agentic_runner_contracts.sealed_credential import (
-    SignInCodeOutcome,
-    SignInCodeRelay,
-    key_fingerprint,
-)
+from agentic_runner_contracts.sealed_credential import key_fingerprint
 
 __all__ = [
     "AGENT_TOKEN_ENV",
@@ -166,6 +164,7 @@ __all__ = [
     "run",
     "run_runner_lifecycle_hook",
     "run_worker_until_terminated",
+    "sign_in_claude",
     "with_profile_acp_cli_kinds",
 ]
 
@@ -657,13 +656,8 @@ class ControlPlaneStream:
     usage_windows: UsageWindows | None = None
     # Local-agents 04b: which delivered references fill the LLM proxy's slot, and where.
     llm_slots: Mapping[str, LlmProvider] = field(default_factory=lambda: dict(LLM_SLOT_REFERENCES))
-    # Local-agents 05: the Claude Code sign-ins a relayed code is typed into.
-    sign_ins: ClaudeSignIns | None = None
     # Console-v2 issue 30: the OAuth Connectors whose code, tokens and verifier stay here.
     oauth: OAuthConnectors | None = None
-    # Reported once, on the beat after the relay: a lost beat loses the outcome, and the
-    # console's own wait on the sign-in is what tells the person.
-    _sign_in_outcomes: list[SignInCodeRelay] = field(default_factory=list)
     _delivered: set[tuple[str, str]] = field(default_factory=set)
     _offered_to_proxy: dict[tuple[str, str], str] = field(default_factory=dict)
     _last_seen: tuple[float, datetime] | None = None
@@ -773,17 +767,14 @@ class ControlPlaneStream:
             clock_skew_seconds=self._clock_skew(now),
             source_status=self.sources.statuses() if self.sources is not None else [],
             tool_servers=self.tool_servers.latest() if self.tool_servers is not None else [],
-            sign_in_codes=self._sign_in_outcomes,
             oauth_authorizations=self.oauth.take_authorizations() if self.oauth else [],
             oauth_tokens=self.oauth.uploads() if self.oauth else [],
             oauth_outcomes=self.oauth.take_outcomes() if self.oauth else [],
         )
-        self._sign_in_outcomes = []
         ack = await self.client.heartbeat(self.state, envelope)
         if self.sources is not None:
             self.sources.assign(ack.user_sources)
         await self._deliver_transcripts(ack)
-        await self._relay_sign_in_codes(ack)
         if self.oauth is not None:
             # Before the sealed values are applied: a Disconnect revokes with the tokens
             # this Runner holds, and the same ack may already have withdrawn their ciphertext.
@@ -836,28 +827,6 @@ class ControlPlaneStream:
                     "transcript %s could not be delivered: %s", request.request_id, error
                 )
 
-    async def _relay_sign_in_codes(self, ack: HeartbeatAck) -> None:
-        """Type each relayed code into the sign-in it names (local-agents 05).
-
-        The code is opened, written to that sign-in's PTY and dropped here; nothing logs
-        it and only its outcome travels back.
-        """
-
-        for sealed in ack.sign_in_codes:
-            code = self.sealed.open_sign_in_code(sealed)
-            if code is None:
-                outcome = SignInCodeOutcome.UNOPENABLE
-            elif self.sign_ins is None:
-                outcome = SignInCodeOutcome.UNKNOWN
-            else:
-                outcome = await self.sign_ins.relay(
-                    str(sealed.contract_id), sealed.sign_in_id, code
-                )
-            del code
-            self._sign_in_outcomes.append(
-                SignInCodeRelay(sign_in_id=sealed.sign_in_id, outcome=outcome)
-            )
-
     def _sync_delivered(self) -> None:
         """The resolver holds exactly what the last ack let this installation open."""
 
@@ -1021,6 +990,42 @@ async def run(
         await readiness.close()
 
 
+async def sign_in_claude(contract_id: str, *, method: str) -> int:
+    """``agentic-runner sign-in``: Claude Code's own flow for one Contract, in this terminal.
+
+    Runs with the Runner's environment (``kubectl exec``, or ``--org`` on a workstation),
+    so the Contract gets the uid and the harness root its Directives already run under.
+    Nothing reaches the control plane: the console only reads the outcome back through
+    ``claude auth status`` (QTS-1448).
+    """
+
+    mode = isolation_mode()
+    can = can_separate_uids()
+    try:
+        require_isolation_supported(mode, can_separate_uids=can)
+    except RunnerRegistrationError as error:
+        print(f"refusing to sign in ({error.reason}): {error}", file=sys.stderr)
+        return 1
+    control_plane = os.environ.get(CONTROL_PLANE_ENV, "").strip()
+    if control_plane:
+        os.environ.setdefault("INTERNAL_FASTAPI_BASE_URL", control_plane)
+    try:
+        settings = get_worker_settings()
+    except ValidationError:
+        print(
+            "refusing to sign in: run this with the Runner's environment "
+            "(`--org <org>` on a workstation, `kubectl exec` into the Runner's pod)",
+            file=sys.stderr,
+        )
+        return 2
+    sign_ins = ClaudeSignIns(build_contract_isolation(settings, can_separate_uids=can))
+    try:
+        return await sign_ins.sign_in(contract_id, method=method)
+    except ClaudeSignInError as error:
+        print(f"sign-in failed: {error}", file=sys.stderr)
+        return 1
+
+
 async def _serve(
     *,
     config: RunnerConfig,
@@ -1157,7 +1162,6 @@ async def _serve_registered(
     messages = MessageStore(state_dir / MESSAGES_DIR)
     stream.messages = messages
     sign_ins = ClaudeSignIns(build_contract_isolation(settings, can_separate_uids=can_change_uid))
-    stream.sign_ins = sign_ins
     stream.oauth = OAuthConnectors(
         sealed=stream.sealed, provider=HttpOAuthProvider(), credentials=credentials
     )
@@ -1243,7 +1247,6 @@ async def _serve_registered(
                 task.cancel()
                 with contextlib.suppress(asyncio.CancelledError):
                     await task
-            await sign_ins.close()
             await run_runner_lifecycle_hook(hooks, HookName.RUNNER_SHUTDOWN)
             await _report_stop(link, lifecycle)
     return 1 if revoked.is_set() else 0

agentic_runner-3.14.0/src/agentic_runner/skill.py

@@ -0,0 +1,58 @@
+"""``agentic-runner skill install | print``: the setup skill for the person's own coding CLI.
+
+The skill (console-v2 issue 21) is read and run by the person's own Claude Code or Codex,
+so the control plane calls no LLM to onboard anyone (ADR-0010 §4). It ships inside the
+wheel so ``uvx agentic-runner skill install`` needs nothing but PyPI, and the copy a CLI
+reads is always the one that matches the Runner it installs.
+"""
+
+from __future__ import annotations
+
+import os
+from collections.abc import Mapping
+from importlib.resources import files
+from pathlib import Path
+from typing import Literal
+
+SKILL_NAME = "agentic-runner-setup"
+
+Target = Literal["claude", "codex"]
+TARGETS: tuple[Target, ...] = ("claude", "codex")
+
+
+def text() -> str:
+    return files("agentic_runner").joinpath("skills", SKILL_NAME, "SKILL.md").read_text("utf-8")
+
+
+def skill_dir(target: Target, *, home: Path, environ: Mapping[str, str]) -> Path:
+    """Where each CLI reads a user skill from.
+
+    Claude Code honours ``CLAUDE_CONFIG_DIR`` for its whole user directory; Codex reads user
+    skills from ``~/.agents/skills``, not from ``CODEX_HOME``.
+    """
+
+    if target == "claude":
+        root = Path(environ.get("CLAUDE_CONFIG_DIR") or home / ".claude")
+    else:
+        root = home / ".agents"
+    return root / "skills" / SKILL_NAME
+
+
+def install(
+    targets: tuple[Target, ...],
+    *,
+    home: Path | None = None,
+    environ: Mapping[str, str] | None = None,
+) -> list[Path]:
+    written = []
+    for target in targets:
+        directory = skill_dir(
+            target,
+            home=home or Path.home(),
+            environ=os.environ if environ is None else environ,
+        )
+        directory.mkdir(parents=True, exist_ok=True)
+        path = directory / "SKILL.md"
+        path.write_text(text(), encoding="utf-8")
+        written.append(path)
+    return written

agentic_runner-3.14.0/src/agentic_runner/skills/agentic-runner-setup/SKILL.md

@@ -0,0 +1,151 @@
+---
+name: agentic-runner-setup
+description: Install and register an Agentic OS Runner on this machine, a Docker host or a Kubernetes cluster, put the Contract's LLM credential in place, and confirm the Runner is online. Use when the person asks to set up, install or connect a Runner, or pastes the prompt from the console's welcome page.
+license: AGPL-3.0-only
+---
+
+# Set up an Agentic OS Runner
+
+You help a person who has never run a Runner. A **Runner** is the program that does their
+Agents' work: it runs Codex or Claude Code on a machine they choose and connects out to the
+Agentic OS control plane. It belongs to one **Organisation** (the company the work is for).
+
+The install documents in the `qtsone/agentic-runner` repository are the source for every
+command. Do not reconstruct a command from memory: open the section named in each step and
+follow it.
+
+## What the person gives you
+
+The prompt they pasted from the console holds these. Ask for any that is missing.
+
+- **Organisation**: a short local name for it, lowercase letters, digits and `-` (`acme`).
+- **Control plane URL**: the Runner's `controlPlane.url`, copied from the console's
+  Runners page. It is the only control plane address you use, and only as a value you
+  pass to the Runner. Never call it or any other control plane address yourself.
+- **Temporal address**: `host:port`, from the same page.
+
+The **Agent Token** is not one of them. It is the reusable credential a Runner registers
+with, and the person types it only where the Runner reads it, never into this
+conversation.
+
+## Rules
+
+- **Say before you run.** Before each command, show the person the exact command and what
+  it does, in one line.
+- **Stop on the first failure.** Show the exact error, link the doc section below that
+  covers it, and stop. Do not retry with other flags, do not work around it.
+- **Never ask for the Agent Token or any credential value in this conversation.** Anything
+  said here reaches the model vendor and stays in this CLI's history. Every command that
+  reads a credential is one the person runs in their own terminal, and the person types the
+  value there. If the person pastes a token or a key here anyway, do not use it: tell them
+  to revoke it in the console and mint or create a new one.
+- You use only the `agentic-runner` command, the standard tools named in the docs (`uv`,
+  `docker`, `kubectl`, `helm`) and read-only checks such as `command -v`.
+
+## Steps
+
+### 1. Look at the machine
+
+Run and report, in one short list:
+
+```sh
+uname -sm
+command -v uv python3 docker kubectl helm codex claude
+```
+
+A Runner does its work with **Codex** or **Claude Code** (each is an Agent Runtime). If the
+way the person picks runs on this machine and neither `codex` nor `claude` is found, say
+so and link their install pages
+(https://developers.openai.com/codex/cli, https://code.claude.com/docs/en/setup). You do
+not install them.
+
+### 2. Ask which way
+
+Ask the person to pick one, and open the matching document:
+
+| Way | When | Document |
+| --- | --- | --- |
+| This machine | A laptop or desktop they use every day. Needs `uv`. | https://github.com/qtsone/agentic-runner/blob/main/docs/workstation.md |
+| Docker | A server or always-on machine with Docker. | https://github.com/qtsone/agentic-runner/blob/main/docs/docker.md |
+| Kubernetes | A cluster they run, with `kubectl` and `helm`. | https://github.com/qtsone/agentic-runner/blob/main/docs/helm.md |
+
+Read its "Before you start" section with the person, and stop if something on it is
+missing.
+
+### 3. Install and register
+
+**This machine.** Follow
+https://github.com/qtsone/agentic-runner/blob/main/docs/workstation.md#install. Install the
+Runner, then show the person the command that registers it for the Organisation and ask
+them to run it in their own terminal. The Runner asks them for the Agent Token there,
+without showing it:
+
+```sh
+uv tool install agentic-runner
+agentic-runner install <org> --control-plane <control-plane-url> --temporal-address <temporal-address>
+```
+
+You run the first line. Do not run the second yourself: wait until the person says it
+finished, and ask for its last lines of output.
+
+**Docker.** Follow
+https://github.com/qtsone/agentic-runner/blob/main/docs/docker.md#the-env-file and then
+https://github.com/qtsone/agentic-runner/blob/main/docs/docker.md#docker-run. Create
+`runner.env` with the URL and the address filled in, and ask the person to add the Agent
+Token line to it themselves.
+
+**Kubernetes.** Follow
+https://github.com/qtsone/agentic-runner/blob/main/docs/helm.md#install. The person creates
+the token Secret themselves (the `read -rs` lines in that section). You run the `helm`
+command.
+
+`registration refused (…)` means the token is revoked or expired, the Account is on hold,
+or the Organisation has reached its Runner limit: the person mints a new token in the
+console. Other errors: the "Check it" section of the same document.
+
+### 4. Put the Contract's LLM credential in place
+
+A **Contract** is the agreement under which the person works for the Organisation. It says
+whose LLM key or subscription the Agents spend. Ask which of the two the Contract uses.
+
+- **An API key (a Credential Reference).** A Credential Reference is the name of a secret
+  whose value lives only on the Runner. On this machine, ask the person to run, in their own
+  terminal, the line from
+  https://github.com/qtsone/agentic-runner/blob/main/docs/workstation.md#operate:
+
+  ```sh
+  printf %s "$VALUE" | agentic-runner credential set <org> <reference>
+  ```
+
+  For Docker and Kubernetes the value is delivered from the console, sealed to the Runner:
+  https://github.com/qtsone/agentic-runner/blob/main/docs/helm.md#the-recipient-key.
+- **A Codex or Claude Code subscription.** This works only on a Runner the person hosts
+  themselves. For Codex, send them to the Contract's page in the console and its
+  **Connect** button. For Claude Code, ask the person to run, in their own terminal, the
+  sign-in line for their way of installing: `agentic-runner sign-in --org <org> --contract
+  <contract-id>` on this machine, or the `docker exec -it` / `kubectl exec -it` line in
+  docker.md or helm.md. See
+  https://github.com/qtsone/agentic-runner/blob/main/docs/workstation.md#sign-in-to-codex-and-claude-code.
+  The sign-in is the person's own, with their own Anthropic account: you never run it, and
+  you do not run `codex login` or `claude auth login`.
+
+### 5. Wait for the Runner to come online
+
+On this machine, run every 10 seconds, for at most 3 minutes:
+
+```sh
+agentic-runner status <org>
+```
+
+The Runner is online when `process` says `running` and `heartbeat` shows a number of
+seconds, not `never`. For Docker and Kubernetes, use the commands in the document's "Check
+it" section. If 3 minutes pass, stop and show the last output and the "Check it" link.
+
+### 6. Report
+
+One screen, nothing more:
+
+- the way, the Organisation and the Runner's identity line from `status`;
+- whether the LLM credential is in place, or the one thing the person still does in the
+  console;
+- the `next` line `status` prints: where in the console to see the Runner and give it work.