@bridge4dev/runner 0.46.1 → 0.48.0

package/dist/agent-registry.d.ts

@@ -0,0 +1,223 @@
+/**
+ * Mirror of the `#region agent-runtimes-mirror` block in
+ * `packages/shared/src/constants/agent-runtimes.ts` — the DevBridge side is the
+ * source of truth, exactly like `protocol.ts` mirrors the API's wire types and
+ * `recipe-schema.ts` mirrors the shared recipe schema.
+ *
+ * Copied rather than imported on purpose: this package is published to npm on
+ * its own and installed by users who have no DevBridge workspace, so a
+ * `@devbridge/shared` import would make the published tarball unresolvable.
+ *
+ * Unlike the older mirrors, this one is CHECKED: `agent-registry.test.ts` reads
+ * both files and compares the region between the `#region` markers character by
+ * character. Edit the shared file first, then paste the region here — nothing
+ * but the region, and nothing of the region left out.
+ *
+ * Why the runner needs it at all: it is the runner, not the server, that knows
+ * which agents exist and how to ask them their version. A command from the
+ * server carries an agent name from a closed list and a version, never a package
+ * name, a URL or anything else executable (§6 of the plan).
+ */
+/**
+ * How an agent is put on a machine — a field, not a branch in the code.
+ *
+ *  - `npm-global` — `npm install -g <package>@<version>`;
+ *  - `script` — the vendor's own installer, downloaded from a URL baked in
+ *    here and run as a file (never `curl | bash`), with the version as its
+ *    argument.
+ */
+export type AgentInstallKind = 'npm-global' | 'script';
+/**
+ * Who owns the copy on the machine, as the agent's own diagnostics report it.
+ *
+ * This is the answer to «may we touch it». Each install kind manages exactly
+ * one value (`script` ↔ `native`, `npm-global` ↔ `npm`); anything else —
+ * Homebrew, a hand-placed binary, Claude installed through the npm package
+ * rather than the native installer, or a machine that would not say — is
+ * someone else's arrangement, and the product shows the command instead of a
+ * button.
+ */
+export type AgentManagedBy = 'native' | 'npm' | 'brew' | 'standalone' | 'unknown';
+/** How the raw text of a probe becomes a version or an install method. */
+export interface AgentProbeSpec {
+    /** Arguments after the binary name. Never a shell string. */
+    readonly argv: readonly string[];
+    /**
+     * Pattern for the first capture group, as SOURCE TEXT rather than a RegExp.
+     *
+     * A `RegExp` literal cannot be copied into the runner's mirror as data, and a
+     * shared mutable object (`lastIndex`) is a poor thing to export. Callers do
+     * `new RegExp(spec.pattern, spec.flags)` — never with `g`.
+     */
+    readonly pattern: string;
+    /** Extra flags for the pattern. `m` where the answer is one line of many. */
+    readonly flags?: string;
+    /**
+     * Present when the probe answers with JSON: the path to the string to match,
+     * key by key. Written as a path because the keys themselves contain dots
+     * (`checks['runtime.provenance']`).
+     */
+    readonly jsonPath?: readonly string[];
+}
+/** Where the newest published version is announced. */
+export interface AgentLatestSpec {
+    /** Primary source: `registry.npmjs.org/-/package/<package>/dist-tags`. */
+    readonly npmPackage: string;
+    /** Which dist-tag counts as «the current one». */
+    readonly npmTag: string;
+    /**
+     * The vendor's own endpoint, used only when the registry could not be asked.
+     * `text` — the body IS the version; `json` — read `field`, then take the
+     * first `1.2.3` in it (`rust-v0.153.4`).
+     */
+    readonly fallback: {
+        readonly url: string;
+        readonly format: 'text' | 'json';
+        readonly field?: string;
+    };
+}
+export interface AgentRuntime {
+    /** Registry key. Lowercase, stable, appears in no database column. */
+    readonly id: string;
+    /** `DevAgent` in Prisma and in every DTO the dashboard reads. */
+    readonly dbValue: string;
+    /** The spelling the runner, the relay and `capabilities.agents` use. */
+    readonly wireKey: string;
+    /** What a person is shown: «Claude Code». */
+    readonly label: string;
+    /** The same name where a row is narrow: «Claude». */
+    readonly shortLabel: string;
+    /** The executable, looked up on the daemon user's PATH. */
+    readonly bin: string;
+    /**
+     * Does this agent report what a turn cost? Claude does, Codex does not — and
+     * a budget that silently never fills is worse than no budget.
+     */
+    readonly reportsCost: boolean;
+    readonly install: {
+        readonly kind: 'npm-global';
+        readonly package: string;
+        readonly managedBy: AgentManagedBy;
+    } | {
+        readonly kind: 'script';
+        readonly url: string;
+        readonly managedBy: AgentManagedBy;
+    };
+    /** `<bin> --version` and how to read its answer. */
+    readonly versionProbe: AgentProbeSpec;
+    /** How the agent's own diagnostics name its install method. Best effort. */
+    readonly managedByProbe: AgentProbeSpec;
+    readonly latest: AgentLatestSpec;
+    /**
+     * Below this the product warns («часть возможностей недоступна») but still
+     * starts the session — Р6. `null` means «no threshold measured yet», which is
+     * not the same as «any version will do»: Claude's number comes from the probe
+     * of stage C1.
+     */
+    readonly minSupported: string | null;
+}
+/** Registry order. It is the order agents appear in every list. */
+export declare const AGENT_RUNTIME_IDS: readonly ["claude", "codex"];
+export type AgentRuntimeId = (typeof AGENT_RUNTIME_IDS)[number];
+export declare const AGENT_RUNTIMES: {
+    readonly claude: {
+        readonly id: "claude";
+        readonly dbValue: "CLAUDE";
+        readonly wireKey: "claude";
+        readonly label: "Claude Code";
+        readonly shortLabel: "Claude";
+        readonly bin: "claude";
+        readonly reportsCost: true;
+        readonly install: {
+            readonly kind: "script";
+            readonly url: "https://claude.ai/install.sh";
+            readonly managedBy: "native";
+        };
+        readonly versionProbe: {
+            readonly argv: readonly ["--version"];
+            readonly pattern: "^(\\d+\\.\\d+\\.\\d+)\\s+\\(Claude Code\\)";
+        };
+        readonly managedByProbe: {
+            readonly argv: readonly ["doctor"];
+            readonly pattern: "^Config install method:\\s*(\\S+)";
+            readonly flags: "m";
+        };
+        readonly latest: {
+            readonly npmPackage: "@anthropic-ai/claude-code";
+            readonly npmTag: "latest";
+            readonly fallback: {
+                readonly url: "https://downloads.claude.ai/claude-code-releases/latest";
+                readonly format: "text";
+            };
+        };
+        readonly minSupported: null;
+    };
+    readonly codex: {
+        readonly id: "codex";
+        readonly dbValue: "CODEX";
+        readonly wireKey: "codex";
+        readonly label: "Codex";
+        readonly shortLabel: "Codex";
+        readonly bin: "codex";
+        readonly reportsCost: false;
+        readonly install: {
+            readonly kind: "npm-global";
+            readonly package: "@openai/codex";
+            readonly managedBy: "npm";
+        };
+        readonly versionProbe: {
+            readonly argv: readonly ["--version"];
+            readonly pattern: "^codex-cli\\s+(\\d+\\.\\d+\\.\\d+)";
+        };
+        readonly managedByProbe: {
+            readonly argv: readonly ["doctor", "--json"];
+            readonly jsonPath: readonly ["checks", "runtime.provenance", "details", "install method"];
+            readonly pattern: "^([A-Za-z-]+)";
+        };
+        readonly latest: {
+            readonly npmPackage: "@openai/codex";
+            readonly npmTag: "latest";
+            readonly fallback: {
+                readonly url: "https://releases.openai.com/codex/channels/latest";
+                readonly format: "json";
+                readonly field: "tag_name";
+            };
+        };
+        readonly minSupported: "0.145.0";
+    };
+};
+/** A semantic version and nothing else — what a runner may report or be told. */
+export declare const AGENT_VERSION_PATTERN = "^\\d+\\.\\d+\\.\\d+$";
+/**
+ * Compare two `1.2.3` strings. `null` when either is not one.
+ *
+ * Deliberately three numeric parts and no pre-release ordering: both vendors
+ * publish plain triples on their release channels, and a comparison that
+ * pretends to understand `-alpha.3` would be a guess wearing a number.
+ */
+export declare function compareAgentVersions(a: string, b: string): number | null;
+/** The agents this runner knows about, in registry order. */
+export declare const AGENT_RUNTIME_LIST: readonly AgentRuntime[];
+/**
+ * The agent a wire name refers to, or `null`.
+ *
+ * `null` and never a default: a name the runner does not recognise must not be
+ * answered with somebody else's binary — the command that carries it installs
+ * software on a stranger's machine.
+ */
+export declare function agentByWireKey(value: string | null | undefined): AgentRuntime | null;
+/** `CLAUDE` → the entry; case is forgiven, unknown names are not. */
+export declare function agentByDbValue(value: string | null | undefined): AgentRuntime | null;
+/**
+ * The two alphabets as literal tuples — written out, not computed.
+ *
+ * `AGENT_RUNTIME_LIST.map((runtime) => runtime.dbValue)` is `string[]`, and a
+ * `z.enum` given that quietly accepts any string: the session descriptor would
+ * stop refusing an agent this build has no adapter for. So they are declared,
+ * and the test below fails the moment they stop matching the registry.
+ */
+export declare const AGENT_DB_VALUES: readonly ["CLAUDE", "CODEX"];
+export type DevAgentName = (typeof AGENT_DB_VALUES)[number];
+export declare const AGENT_WIRE_KEYS: readonly ["claude", "codex"];
+export type RelayAgentName = (typeof AGENT_WIRE_KEYS)[number];
+//# sourceMappingURL=agent-registry.d.ts.map

package/dist/agent-registry.js

@@ -0,0 +1,131 @@
+/**
+ * Mirror of the `#region agent-runtimes-mirror` block in
+ * `packages/shared/src/constants/agent-runtimes.ts` — the DevBridge side is the
+ * source of truth, exactly like `protocol.ts` mirrors the API's wire types and
+ * `recipe-schema.ts` mirrors the shared recipe schema.
+ *
+ * Copied rather than imported on purpose: this package is published to npm on
+ * its own and installed by users who have no DevBridge workspace, so a
+ * `@devbridge/shared` import would make the published tarball unresolvable.
+ *
+ * Unlike the older mirrors, this one is CHECKED: `agent-registry.test.ts` reads
+ * both files and compares the region between the `#region` markers character by
+ * character. Edit the shared file first, then paste the region here — nothing
+ * but the region, and nothing of the region left out.
+ *
+ * Why the runner needs it at all: it is the runner, not the server, that knows
+ * which agents exist and how to ask them their version. A command from the
+ * server carries an agent name from a closed list and a version, never a package
+ * name, a URL or anything else executable (§6 of the plan).
+ */
+/** Registry order. It is the order agents appear in every list. */
+export const AGENT_RUNTIME_IDS = ['claude', 'codex'];
+export const AGENT_RUNTIMES = {
+    claude: {
+        id: 'claude',
+        dbValue: 'CLAUDE',
+        wireKey: 'claude',
+        label: 'Claude Code',
+        shortLabel: 'Claude',
+        bin: 'claude',
+        reportsCost: true,
+        install: { kind: 'script', url: 'https://claude.ai/install.sh', managedBy: 'native' },
+        versionProbe: { argv: ['--version'], pattern: '^(\\d+\\.\\d+\\.\\d+)\\s+\\(Claude Code\\)' },
+        managedByProbe: {
+            argv: ['doctor'],
+            pattern: '^Config install method:\\s*(\\S+)',
+            flags: 'm',
+        },
+        latest: {
+            npmPackage: '@anthropic-ai/claude-code',
+            npmTag: 'latest',
+            fallback: { url: 'https://downloads.claude.ai/claude-code-releases/latest', format: 'text' },
+        },
+        minSupported: null,
+    },
+    codex: {
+        id: 'codex',
+        dbValue: 'CODEX',
+        wireKey: 'codex',
+        label: 'Codex',
+        shortLabel: 'Codex',
+        bin: 'codex',
+        reportsCost: false,
+        install: { kind: 'npm-global', package: '@openai/codex', managedBy: 'npm' },
+        versionProbe: { argv: ['--version'], pattern: '^codex-cli\\s+(\\d+\\.\\d+\\.\\d+)' },
+        managedByProbe: {
+            argv: ['doctor', '--json'],
+            jsonPath: ['checks', 'runtime.provenance', 'details', 'install method'],
+            pattern: '^([A-Za-z-]+)',
+        },
+        latest: {
+            npmPackage: '@openai/codex',
+            npmTag: 'latest',
+            fallback: {
+                url: 'https://releases.openai.com/codex/channels/latest',
+                format: 'json',
+                field: 'tag_name',
+            },
+        },
+        // Below 0.145.0 there is no `thread/compact/start`, so a session cannot
+        // compact its context at all (`packages/runner/src/adapters/codex.ts`).
+        minSupported: '0.145.0',
+    },
+};
+/** A semantic version and nothing else — what a runner may report or be told. */
+export const AGENT_VERSION_PATTERN = '^\\d+\\.\\d+\\.\\d+$';
+/**
+ * Compare two `1.2.3` strings. `null` when either is not one.
+ *
+ * Deliberately three numeric parts and no pre-release ordering: both vendors
+ * publish plain triples on their release channels, and a comparison that
+ * pretends to understand `-alpha.3` would be a guess wearing a number.
+ */
+export function compareAgentVersions(a, b) {
+    const left = parseAgentVersion(a);
+    const right = parseAgentVersion(b);
+    if (!left || !right)
+        return null;
+    for (let index = 0; index < 3; index += 1) {
+        const diff = (left[index] ?? 0) - (right[index] ?? 0);
+        if (diff !== 0)
+            return diff < 0 ? -1 : 1;
+    }
+    return 0;
+}
+function parseAgentVersion(value) {
+    const match = /^(\d+)\.(\d+)\.(\d+)$/.exec(value.trim());
+    if (!match)
+        return null;
+    return [Number(match[1]), Number(match[2]), Number(match[3])];
+}
+// #endregion agent-runtimes-mirror
+/** The agents this runner knows about, in registry order. */
+export const AGENT_RUNTIME_LIST = AGENT_RUNTIME_IDS.map((id) => AGENT_RUNTIMES[id]);
+const BY_WIRE_KEY = new Map(AGENT_RUNTIME_LIST.map((runtime) => [runtime.wireKey, runtime]));
+/**
+ * The agent a wire name refers to, or `null`.
+ *
+ * `null` and never a default: a name the runner does not recognise must not be
+ * answered with somebody else's binary — the command that carries it installs
+ * software on a stranger's machine.
+ */
+export function agentByWireKey(value) {
+    return BY_WIRE_KEY.get(String(value ?? '').toLowerCase()) ?? null;
+}
+/** `CLAUDE` → the entry; case is forgiven, unknown names are not. */
+export function agentByDbValue(value) {
+    const wanted = String(value ?? '').toUpperCase();
+    return AGENT_RUNTIME_LIST.find((runtime) => runtime.dbValue === wanted) ?? null;
+}
+/**
+ * The two alphabets as literal tuples — written out, not computed.
+ *
+ * `AGENT_RUNTIME_LIST.map((runtime) => runtime.dbValue)` is `string[]`, and a
+ * `z.enum` given that quietly accepts any string: the session descriptor would
+ * stop refusing an agent this build has no adapter for. So they are declared,
+ * and the test below fails the moment they stop matching the registry.
+ */
+export const AGENT_DB_VALUES = ['CLAUDE', 'CODEX'];
+export const AGENT_WIRE_KEYS = ['claude', 'codex'];
+//# sourceMappingURL=agent-registry.js.map

package/dist/agent-versions.d.ts

@@ -0,0 +1,93 @@
+import { type AgentManagedBy, type AgentRuntime } from './agent-registry.js';
+/**
+ * What is actually installed on this machine, measured by asking the binaries.
+ *
+ * The product could not answer «which Claude is on that server» at all before
+ * this: the version travelled nowhere, so a card showed a machine and said
+ * nothing about the two CLIs the whole product runs on. Everything here is one
+ * half of that answer — the other half is the `agent_versions` frame in
+ * `supervisor.ts`, which carries it up.
+ *
+ * Three rules, each from something that would otherwise bite:
+ *
+ *  1. **`null` is «not installed», and it is a normal answer.** A machine
+ *     without Codex is not a broken machine; the card draws «Install» for it.
+ *     A probe that FAILED is also `null` for the version, and the log line is
+ *     where the difference lives — inventing a third state on the wire would
+ *     make every reader handle a case they cannot act on.
+ *  2. **The version comes from `--version`, the install method from the agent's
+ *     own diagnostics.** Guessing ownership from a path would call a Homebrew
+ *     Claude «native» and offer a button that fights Homebrew.
+ *  3. **Measured at most once an hour.** The runner reconnects dozens of times
+ *     a day (#227) and re-sends this frame on every `hello_ack`; spawning four
+ *     processes each time would be a tax on the machine for no new fact.
+ */
+/** One agent, as this machine has it. */
+export interface MeasuredAgentVersion {
+    /** `null` — the binary is not on the daemon user's PATH, or would not answer. */
+    version: string | null;
+    managedBy: AgentManagedBy;
+    /**
+     * The binary WAS there and the probe still produced no version.
+     *
+     * The difference matters more than it looks: without it a ten-second timeout
+     * on a loaded machine reaches the dashboard as «Claude is not installed
+     * here», the agent is greyed out of the New session window, and it stays that
+     * way for the hour this measurement is cached. Absence is a claim, and a
+     * claim needs evidence — this flag is what withholds it.
+     */
+    probeFailed?: boolean;
+}
+export interface AgentVersionsMeasurement {
+    /** When the machine took the measurement, ISO — the frame's `at`. */
+    at: string;
+    /** Keyed by the registry's wire name (`claude`, `codex`). */
+    agents: Record<string, MeasuredAgentVersion>;
+}
+/** How long a measurement is believed. See rule 3 above. */
+export declare const AGENT_VERSIONS_CACHE_MS: number;
+/**
+ * Forget the cached measurement.
+ *
+ * Called after an install (stage B) and by tests. Without it the card would go
+ * on showing the old version for up to an hour after a successful update, which
+ * reads as «the button did nothing».
+ */
+export declare function invalidateAgentVersions(): void;
+export interface ProbeResult {
+    stdout: string;
+    stderr: string;
+}
+/** Run one probe. Rejects on a non-zero exit, a timeout or a missing binary. */
+export type ProbeRunner = (file: string, argv: readonly string[], timeoutMs: number) => Promise<ProbeResult>;
+/**
+ * Fold whatever an agent calls its install method into the five values the
+ * product reasons about.
+ *
+ * Unknown wording becomes `unknown`, which means «show the command, offer no
+ * button» — the safe direction: the alternative is a button that runs the wrong
+ * package manager on somebody else's machine.
+ */
+export declare function normalizeManagedBy(raw: string | null | undefined): AgentManagedBy;
+/**
+ * Measure one agent: its version and how it was installed.
+ *
+ * Exported because the install path (`agent-install.ts`) needs exactly this
+ * answer twice — once before it touches anything, once as the smoke test after.
+ * Reusing it rather than probing separately keeps the number of ways this
+ * product can answer «is that agent installed, and which one» at three rather
+ * than four: `installedAgents()`, the `agentClis` capability, and this.
+ */
+export declare function measureAgent(runtime: AgentRuntime, run?: ProbeRunner): Promise<MeasuredAgentVersion>;
+/**
+ * Measure every agent in the registry, or hand back the cached answer.
+ *
+ * Probes run in parallel: they are independent, and a Codex doctor that is slow
+ * to answer must not delay the Claude row.
+ */
+export declare function measureAgentVersions(options?: {
+    force?: boolean;
+    now?: () => number;
+    run?: ProbeRunner;
+}): Promise<AgentVersionsMeasurement>;
+//# sourceMappingURL=agent-versions.d.ts.map

package/dist/agent-versions.js

@@ -0,0 +1,157 @@
+import { execFile } from 'node:child_process';
+import { AGENT_RUNTIME_LIST, } from './agent-registry.js';
+import { whichExecutable } from './environment.js';
+import { log } from './log.js';
+/**
+ * How long a probe may take before it is written off.
+ *
+ * Ten seconds is the number every other probe in this package uses
+ * (`environment.ts`, `auth-relay.ts`); `codex doctor --json` checks the release
+ * channel over the network and took ~250 ms on a live machine, so the margin is
+ * for a machine under load rather than for the work.
+ */
+const PROBE_TIMEOUT_MS = 10_000;
+/** Doctor output is a page of JSON; a megabyte is a hundred times enough. */
+const PROBE_MAX_BUFFER = 1_024 * 1_024;
+/** How long a measurement is believed. See rule 3 above. */
+export const AGENT_VERSIONS_CACHE_MS = 60 * 60 * 1_000;
+let cached = null;
+/**
+ * Forget the cached measurement.
+ *
+ * Called after an install (stage B) and by tests. Without it the card would go
+ * on showing the old version for up to an hour after a successful update, which
+ * reads as «the button did nothing».
+ */
+export function invalidateAgentVersions() {
+    cached = null;
+}
+const runProbe = (file, argv, timeoutMs) => new Promise((resolve, reject) => {
+    const child = execFile(file, [...argv], { timeout: timeoutMs, maxBuffer: PROBE_MAX_BUFFER }, (error, stdout, stderr) => {
+        if (error)
+            reject(error);
+        else
+            resolve({ stdout, stderr });
+    });
+    // `claude doctor` reads stdin. An `execFile` child inherits an open pipe
+    // nobody ever writes to, so without this EOF the probe would sit there
+    // until the timeout killed it — measured, not assumed.
+    child.stdin?.end();
+});
+function matchProbe(spec, output) {
+    const match = new RegExp(spec.pattern, spec.flags).exec(output);
+    return match?.[1] ?? null;
+}
+function readJsonPath(raw, jsonPath) {
+    let value;
+    try {
+        value = JSON.parse(raw);
+    }
+    catch {
+        return null;
+    }
+    for (const key of jsonPath) {
+        if (!value || typeof value !== 'object' || Array.isArray(value))
+            return null;
+        value = value[key];
+    }
+    return typeof value === 'string' ? value : null;
+}
+/**
+ * Fold whatever an agent calls its install method into the five values the
+ * product reasons about.
+ *
+ * Unknown wording becomes `unknown`, which means «show the command, offer no
+ * button» — the safe direction: the alternative is a button that runs the wrong
+ * package manager on somebody else's machine.
+ */
+export function normalizeManagedBy(raw) {
+    const value = String(raw ?? '')
+        .trim()
+        .toLowerCase();
+    if (value === 'native')
+        return 'native';
+    if (value === 'npm' || value === 'npm-global' || value === 'global')
+        return 'npm';
+    if (value === 'brew' || value === 'homebrew')
+        return 'brew';
+    if (value === 'standalone' || value === 'binary' || value === 'local')
+        return 'standalone';
+    return 'unknown';
+}
+/**
+ * Measure one agent: its version and how it was installed.
+ *
+ * Exported because the install path (`agent-install.ts`) needs exactly this
+ * answer twice — once before it touches anything, once as the smoke test after.
+ * Reusing it rather than probing separately keeps the number of ways this
+ * product can answer «is that agent installed, and which one» at three rather
+ * than four: `installedAgents()`, the `agentClis` capability, and this.
+ */
+export async function measureAgent(runtime, run = runProbe) {
+    const binary = whichExecutable(runtime.bin);
+    if (!binary)
+        return { version: null, managedBy: 'unknown' };
+    let version;
+    try {
+        const { stdout, stderr } = await run(binary, runtime.versionProbe.argv, PROBE_TIMEOUT_MS);
+        // Some CLIs print the version on stderr; reading both costs nothing and
+        // saves a per-agent exception.
+        version = matchProbe(runtime.versionProbe, `${stdout}\n${stderr}`);
+        if (!version) {
+            log.warn('agent-versions: could not read a version', {
+                agent: runtime.wireKey,
+                output: `${stdout}${stderr}`.slice(0, 200),
+            });
+            // The binary answered something we cannot parse — a vendor that changed
+            // its line. It is here, so nothing may say otherwise.
+            return { version: null, managedBy: 'unknown', probeFailed: true };
+        }
+    }
+    catch (error) {
+        log.warn('agent-versions: version probe failed', {
+            agent: runtime.wireKey,
+            error: String(error instanceof Error ? error.message : error),
+        });
+        return { version: null, managedBy: 'unknown', probeFailed: true };
+    }
+    // The install method is a nice-to-have: it decides whether a BUTTON appears,
+    // never whether the version is shown. A doctor that failed leaves `unknown`.
+    let managedBy = 'unknown';
+    try {
+        const probe = runtime.managedByProbe;
+        const { stdout, stderr } = await run(binary, probe.argv, PROBE_TIMEOUT_MS);
+        const output = `${stdout}\n${stderr}`;
+        const source = probe.jsonPath ? readJsonPath(stdout, probe.jsonPath) : output;
+        managedBy = normalizeManagedBy(source ? matchProbe(probe, source) : null);
+    }
+    catch (error) {
+        log.warn('agent-versions: install-method probe failed', {
+            agent: runtime.wireKey,
+            error: String(error instanceof Error ? error.message : error),
+        });
+    }
+    return { version, managedBy };
+}
+/**
+ * Measure every agent in the registry, or hand back the cached answer.
+ *
+ * Probes run in parallel: they are independent, and a Codex doctor that is slow
+ * to answer must not delay the Claude row.
+ */
+export async function measureAgentVersions(options = {}) {
+    const now = options.now ?? Date.now;
+    const nowMs = now();
+    if (!options.force && cached && nowMs - cached.takenAtMs < AGENT_VERSIONS_CACHE_MS) {
+        return cached.measurement;
+    }
+    const run = options.run ?? runProbe;
+    const results = await Promise.all(AGENT_RUNTIME_LIST.map(async (runtime) => [runtime.wireKey, await measureAgent(runtime, run)]));
+    const measurement = {
+        at: new Date(nowMs).toISOString(),
+        agents: Object.fromEntries(results),
+    };
+    cached = { takenAtMs: nowMs, measurement };
+    return measurement;
+}
+//# sourceMappingURL=agent-versions.js.map

package/dist/auth-relay.d.ts

@@ -1,4 +1,12 @@
-export type RelayAgent = 'claude' | 'codex';
+import { type RelayAgentName } from './agent-registry.js';
+/**
+ * The agents the login relay can drive — the registry's wire alphabet (Р15).
+ *
+ * Re-exported under the name every caller already uses rather than renamed at
+ * ~20 call sites: the point of the registry is that the list has one home, not
+ * that every file learns a new word for it.
+ */
+export type RelayAgent = RelayAgentName;
 export interface LoginStartResult {
     url: string;
     /** Device-auth style user code to enter on the provider page (Codex). */

package/dist/auth-relay.js

@@ -159,7 +159,9 @@ export class AuthRelay {
         if (!commandExists(command)) {
             const binary = command.trim().split(/\s+/)[0] ?? agent;
             throw new Error(`\`${binary}\` is not installed for ${runnerIdentity().user} on this server — ` +
-                'install the agent CLI for that user (or use the installer’s --user mode, which does it) and try again');
+                // The installer stopped installing agents in 0.47.0 (Р9 of #371), so
+                // «use --user mode, which does it» is no longer true of anything.
+                'press «Install» on this agent’s row in the server card and try again');
         }
         if (!whichExecutable('script')) {
             // util-linux, and the only reason a pty exists here at all.

package/dist/commit-message.js

@@ -1,4 +1,5 @@
 import { query } from '@anthropic-ai/claude-agent-sdk';
+import { claudeExecutableOption } from './agent-binary.js';
 import { scrubbedEnv } from './adapters/claude.js';
 import { gitBranchDiff } from './gitops.js';
 import { isSecretPath, maskString } from './policy.js';
@@ -153,6 +154,10 @@ export async function proposeCommitMessage(input, queryFn = query) {
             options: {
                 cwd: input.worktreePath,
                 env: scrubbedEnv(),
+                // The second place Claude `Options` are built. It must follow the same
+                // constant, or after C3 commit messages would still be written by the
+                // bundled binary while sessions had moved to the system one.
+                ...claudeExecutableOption(),
                 settingSources: [],
                 maxTurns: 1,
                 // Belt and braces: an empty allowlist is a statement of intent, the