@skrr-ai/cli 0.1.50 → 0.1.51

package/dist/lib/auth-failure.js

@@ -0,0 +1,65 @@
+"use strict";
+/**
+ * auth-failure.ts — say WHY a request was refused on authentication (OSK-12116).
+ *
+ * A 401 reaches the CLI after its own renewal has already failed: the access
+ * token expired, the refresh was refused, and the retry went out with the dead
+ * token. The server's answer to that retry is `TOKEN_EXPIRED`, which is true and
+ * useless — the expiry is routine, the refusal to RENEW is the fault, and it was
+ * visible only as an `[auth-core warn]` line on stderr.
+ *
+ * auth-core latches every permanent refresh refusal (`needs-reauth.json`, the
+ * same record `skrr whoami` prints as "Refresh state"). This module reads that
+ * latch and turns it into the sentence the error should have carried.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.describeRefreshRefusal = describeRefreshRefusal;
+/**
+ * Explain one refresh refusal in terms of what the reader can do about it.
+ * Returns null when there is no latched refusal, so the caller keeps its
+ * generic wording rather than inventing a cause.
+ */
+function describeRefreshRefusal(refusal, opts) {
+    if (!refusal?.reason)
+        return null;
+    const { bin } = opts;
+    const code = refusal.reason;
+    const said = refusal.message ? ` (${code}: ${refusal.message})` : ` (${code})`;
+    const relogin = `Run \`${bin} login\` to sign in again.`;
+    const message = refusal.message ?? '';
+    // The row the stored refresh token belongs to was minted for a different CLI
+    // identity than the one this config presents. The keychain slot is keyed by
+    // profile, while the CLI ID lives in the config directory — so a second skrr
+    // configuration on this machine (a different HOME or config dir sharing the
+    // same login Keychain) can write this profile's credential under its own ID.
+    // Observed: a token minted for `cli_devin_dogfood` sitting in the default
+    // profile's slot.
+    if (/bound to a different daemon/i.test(message)) {
+        return {
+            code,
+            message: `This profile's stored sign-in could not be renewed${said}. The credential in its ` +
+                `Keychain slot was issued to a different CLI identity than this one` +
+                `${opts.cliId ? ` (${opts.cliId})` : ''} — usually another skrr configuration on this ` +
+                `machine (a different HOME or config directory) signed in and wrote over it. ${relogin}`,
+        };
+    }
+    if (code === 'SESSION_REVOKED') {
+        return {
+            code,
+            message: `This sign-in was revoked${said}. Signing out elsewhere revokes it, and so does ` +
+                `revoking a daemon that brokered it (\`${bin} login\` without a browser signs in ` +
+                `through this machine's daemon). ${relogin}`,
+        };
+    }
+    if (code === 'REFRESH_REUSED') {
+        return {
+            code,
+            message: `This sign-in was ended because its refresh token was presented twice${said}; the ` +
+                `server treats that as possible theft and revokes the whole family. ${relogin}`,
+        };
+    }
+    return {
+        code,
+        message: `This sign-in could not be renewed${said}. ${relogin}`,
+    };
+}

package/dist/lib/commitments.d.ts

@@ -17,7 +17,7 @@
  * "hold this state", derived from a Compass invariant — not authored here).
  */
 import { COMMITMENT_WATCHED_SOURCES, COMMITMENT_TEMPLATE_IDS, COMMITMENT_CADENCE_MODES, COMMITMENT_CADENCE_TIME_PATTERN, COMMITMENT_CADENCE_MAX_TIMES, COMMITMENT_AUTONOMY_MODES, COMMITMENT_EXECUTION_ISOLATION_MODES, COMMITMENT_STATUSES, COMMITMENT_KIND_VALUES } from '@skrr-ai/data-provider';
-import type { CommitmentCheck, CommitmentChecksResponse, Commitment, CommitmentActionProposal, CommitmentListResponse, CommitmentPlanResponse, CommitmentStatusResponse, CommitmentWorkLink, CommitmentExecutionReceiptListResponse, CommitmentExecutionReceiptQuarterlyMetricsResponse, CommitmentCapabilitySource, CommitmentDeliveryPatchResponse, CommitmentDeliveryBundleResponse, CommitmentCyclesResponse, CommitmentExplanationResponse } from '@skrr-ai/data-provider';
+import type { CommitmentCheck, CommitmentChecksResponse, Commitment, CommitmentActionProposal, CommitmentListResponse, CommitmentPlanResponse, CommitmentStatusResponse, CommitmentWorkLink, CommitmentExecutionReceiptListResponse, CommitmentExecutionReceiptQuarterlyMetricsResponse, CommitmentCapabilitySource, CommitmentDeliveryPatchResponse, CommitmentDeliveryBundleResponse, CommitmentCyclesResponse, CommitmentExplanationResponse, CommitmentRunPermissions } from '@skrr-ai/data-provider';
 import { withQuery } from './triggers';
 export { COMMITMENT_WATCHED_SOURCES, COMMITMENT_TEMPLATE_IDS, COMMITMENT_CADENCE_MODES, COMMITMENT_CADENCE_TIME_PATTERN, COMMITMENT_CADENCE_MAX_TIMES, COMMITMENT_STATUSES, COMMITMENT_KIND_VALUES, };
 export type { CommitmentCheck, CommitmentChecksResponse, Commitment, CommitmentActionProposal, CommitmentListResponse, CommitmentPlanResponse, CommitmentStatusResponse, CommitmentWorkLink, };
@@ -99,7 +99,27 @@ export type CommitmentPreflightReport = {
         suppressedBy?: string | null;
         [key: string]: unknown;
     };
+    /** Whose permissions a run uses (OSK-11975). Absent from older servers. */
+    permissions?: CommitmentRunPermissions | null;
+    /** `retired` names the fence fields OSK-11975 made inert (OSK-12065). */
+    execution?: {
+        retired?: string[];
+        retiredReason?: string;
+    } & Record<string, unknown>;
 };
+/**
+ * The lines every Commitment read surface prints for "whose permissions does a
+ * run use?" — `show`, `effective-policy` and `preflight` share it so the three
+ * cannot phrase it three ways (OSK-12065). The sentence and the warnings are
+ * the server's; this only lays them out. `null` (an older server that does not
+ * report it) prints nothing rather than a guess.
+ */
+export declare function permissionLines(permissions: CommitmentRunPermissions | null | undefined): string[];
+/**
+ * One line naming fields that are still in the JSON but decide nothing any
+ * more. Deprecation, not removal: `--json` keeps them for scripts.
+ */
+export declare function retiredFieldsLine(retired: string[] | undefined, reason: string | undefined): string | null;
 /**
  * A Commitment Pack's readiness receipt.
  *

package/dist/lib/commitments.js

@@ -4,6 +4,8 @@ exports.COMMITMENT_CLI_EVALUATORS = exports.COMMITMENT_CREATE_KEYS = exports.COM
 exports.storedAutonomyModeForAuthoring = storedAutonomyModeForAuthoring;
 exports.authoringAutonomyModeForStored = authoringAutonomyModeForStored;
 exports.commitmentAutonomyLabel = commitmentAutonomyLabel;
+exports.permissionLines = permissionLines;
+exports.retiredFieldsLine = retiredFieldsLine;
 exports.readCommitmentAgentDirective = readCommitmentAgentDirective;
 exports.normalizeCreateBody = normalizeCreateBody;
 exports.parseCommitmentConcurrencyLimit = parseCommitmentConcurrencyLimit;
@@ -109,6 +111,33 @@ function commitmentAutonomyLabel(mode) {
  */
 exports.MIN_COMMITMENT_INTERVAL_MS = 60_000;
 exports.MAX_COMMITMENT_INTERVAL_MS = 365 * 24 * 60 * 60 * 1000;
+/**
+ * The lines every Commitment read surface prints for "whose permissions does a
+ * run use?" — `show`, `effective-policy` and `preflight` share it so the three
+ * cannot phrase it three ways (OSK-12065). The sentence and the warnings are
+ * the server's; this only lays them out. `null` (an older server that does not
+ * report it) prints nothing rather than a guess.
+ */
+function permissionLines(permissions) {
+    if (!permissions?.summary)
+        return [];
+    const lines = [`Permissions: ${permissions.summary}`];
+    for (const warning of permissions.warnings || []) {
+        lines.push(`Warning: ${warning.message}`);
+        if (warning.fix)
+            lines.push(`  Fix: ${warning.fix}`);
+    }
+    return lines;
+}
+/**
+ * One line naming fields that are still in the JSON but decide nothing any
+ * more. Deprecation, not removal: `--json` keeps them for scripts.
+ */
+function retiredFieldsLine(retired, reason) {
+    if (!Array.isArray(retired) || !retired.length)
+        return null;
+    return `Retired fields (no effect): ${retired.join(', ')}${reason ? ` — ${reason}` : ''}`;
+}
 function base(id) {
     return `/api/commitments/${encodeURIComponent(id)}`;
 }
@@ -1013,6 +1042,11 @@ function describeWakeDecision(check) {
     if (verdict === 'skipped') {
         const reason = typeof entry.reason === 'string' ? entry.reason : '';
         if (reason === 'posture_does_not_admit_agent_run') {
+            // The server names the commonest cause on the check's `stop`: nothing
+            // was open to act on. "record_only" alone read as a setting to change
+            // when the remedy was to give the Commitment some work (OSK-12090).
+            if (check.stop?.reason === 'no_open_loop')
+                return 'no — nothing open';
             const posture = typeof entry.posture === 'string' ? entry.posture : '';
             return posture ? `no — ${posture}` : 'no — posture';
         }

package/dist/lib/daemonBroker.d.ts

@@ -138,6 +138,12 @@ export interface DaemonBrokerFailure {
      * the daemon".
      */
     daemonServerUrl?: string;
+    /**
+     * For `base_url_mismatch` found locally: the descriptor file that named
+     * `daemonServerUrl`, so a message can say what was read rather than assert
+     * where "the" daemon is logged in (OSK-12117).
+     */
+    descriptorPath?: string;
 }
 export type DaemonBrokerOutcome = (DaemonBrokerResult & {
     ok: true;
@@ -224,6 +230,14 @@ export declare function resolveBootstrapCandidatePaths(profile?: string): string
 export declare const DEDICATED_RUNTIME_CLI_HANDOFF_DESCRIPTOR = "/run/skrr-dedicated-runtime/cli-handoff/descriptor.json";
 /** Where the cli-handoff broker looks, in order. */
 export declare function resolveCliHandoffCandidatePaths(profile?: string): string[];
+/**
+ * The island files that belong to exactly `profile` — its canonical path and
+ * the pre-rename darwin location — and never another profile's. The broker's
+ * candidate list for `default` deliberately falls through to any running
+ * profile, which is right for borrowing a credential and wrong for naming
+ * which daemon a profile's status describes (OSK-12102).
+ */
+export declare function resolveExactProfileBootstrapPaths(profile?: string): string[];
 /**
  * Resolve the first live daemon bootstrap for a profile. Message-intent
  * submission reuses the same authenticated loopback discovery as the login

package/dist/lib/daemonBroker.js

@@ -77,6 +77,7 @@ exports.resolveBootstrapPath = resolveBootstrapPath;
 exports.resolveProfileBootstrapPaths = resolveProfileBootstrapPaths;
 exports.resolveBootstrapCandidatePaths = resolveBootstrapCandidatePaths;
 exports.resolveCliHandoffCandidatePaths = resolveCliHandoffCandidatePaths;
+exports.resolveExactProfileBootstrapPaths = resolveExactProfileBootstrapPaths;
 exports.findLiveDaemonBootstrap = findLiveDaemonBootstrap;
 exports.readBootstrap = readBootstrap;
 exports.attemptDaemonBrokerLogin = attemptDaemonBrokerLogin;
@@ -91,6 +92,7 @@ const fs = __importStar(require("node:fs"));
 const path = __importStar(require("node:path"));
 const os = __importStar(require("node:os"));
 const auth_core_1 = require("@skrr-ai/auth-core");
+const loopback_http_1 = require("@skrr-ai/auth-core/loopback-http");
 const cli_handoff_wire_1 = require("@skrr-ai/auth-core/cli-handoff-wire");
 const auth_storage_1 = require("./auth-storage");
 const config_1 = require("./config");
@@ -139,6 +141,16 @@ function resolveProfileBootstrapPaths(primary, entryNames) {
         .map((name) => path.join(path.dirname(primary), name));
     return [primary, ...extras];
 }
+/**
+ * Legacy bootstrap directory (darwin): pre-rename daemons wrote under
+ * `~/Library/Application Support/OverSky/` while this reader looked under
+ * `skrr/` — a drift that silently killed island bootstrapping on macOS
+ * (OSK-12057). New daemons dual-write both; old daemons keep writing only
+ * `OverSky/`, so these stay consulted as fallbacks.
+ */
+function legacyDarwinBootstrapDir() {
+    return path.join(os.homedir(), 'Library', 'Application Support', 'OverSky');
+}
 /**
  * List the bootstrap files that a Sky CLI may use for a local daemon
  * handoff. `default` stays first for backwards compatibility; any other
@@ -150,16 +162,31 @@ function resolveProfileBootstrapPaths(primary, entryNames) {
  */
 function resolveBootstrapCandidatePaths(profile = 'default') {
     const primary = resolveBootstrapPath(profile);
-    if (profile !== 'default')
-        return [primary];
+    if (profile !== 'default') {
+        const legacy = process.platform === 'darwin'
+            ? [path.join(legacyDarwinBootstrapDir(), `daemon-island.${profile}.json`)]
+            : [];
+        return [primary, ...legacy];
+    }
     try {
         if (process.platform === 'darwin') {
-            const dir = path.dirname(primary);
-            const entryNames = fs
-                .readdirSync(dir, { withFileTypes: true })
-                .filter((entry) => entry.isFile())
-                .map((entry) => entry.name);
-            return resolveProfileBootstrapPaths(primary, entryNames);
+            const candidates = [primary];
+            for (const dir of [path.dirname(primary), legacyDarwinBootstrapDir()]) {
+                let entryNames = [];
+                try {
+                    entryNames = fs
+                        .readdirSync(dir, { withFileTypes: true })
+                        .filter((entry) => entry.isFile())
+                        .map((entry) => entry.name);
+                }
+                catch {
+                    continue;
+                }
+                for (const p of resolveProfileBootstrapPaths(path.join(dir, 'daemon-island.default.json'), entryNames)) {
+                    candidates.push(p);
+                }
+            }
+            return [...new Set(candidates)];
         }
         const profilesDir = path.dirname(path.dirname(primary));
         const extras = fs
@@ -208,6 +235,20 @@ function resolveCliHandoffCandidatePaths(profile = 'default') {
 function legacyBootstrapPath() {
     return path.join(os.homedir(), '.skrr', 'daemon-island.json');
 }
+/**
+ * The island files that belong to exactly `profile` — its canonical path and
+ * the pre-rename darwin location — and never another profile's. The broker's
+ * candidate list for `default` deliberately falls through to any running
+ * profile, which is right for borrowing a credential and wrong for naming
+ * which daemon a profile's status describes (OSK-12102).
+ */
+function resolveExactProfileBootstrapPaths(profile = 'default') {
+    const primary = resolveBootstrapPath(profile);
+    if (process.platform === 'darwin') {
+        return [primary, path.join(legacyDarwinBootstrapDir(), `daemon-island.${profile}.json`)];
+    }
+    return profile === 'default' ? [primary, legacyBootstrapPath()] : [primary];
+}
 /**
  * Resolve the first live daemon bootstrap for a profile. Message-intent
  * submission reuses the same authenticated loopback discovery as the login
@@ -301,6 +342,7 @@ async function attemptDaemonBrokerLogin(opts) {
     const usable = [];
     const unbound = [];
     let mismatchedBootstrap = null;
+    let mismatchedPath = null;
     for (const candidate of candidates) {
         const candidateBootstrap = readBootstrap(candidate);
         if (!candidateBootstrap)
@@ -310,7 +352,10 @@ async function attemptDaemonBrokerLogin(opts) {
             typeof opts.baseURL === 'string' &&
             opts.baseURL.length > 0 &&
             normalizeBaseUrl(opts.baseURL) !== normalizeBaseUrl(candidateBootstrap.serverUrl)) {
-            mismatchedBootstrap ??= candidateBootstrap;
+            if (!mismatchedBootstrap) {
+                mismatchedBootstrap = candidateBootstrap;
+                mismatchedPath = candidate;
+            }
             continue;
         }
         if (typeof candidateBootstrap.serverUrl !== 'string' ||
@@ -326,8 +371,11 @@ async function attemptDaemonBrokerLogin(opts) {
             return {
                 ok: false,
                 reason: 'base_url_mismatch',
-                detail: `The skrr background service on this computer is not logged in to ${opts.baseURL}; it is logged in to ${mismatchedBootstrap.serverUrl}.`,
+                // What was READ, not a claim about the daemon: the descriptor may be
+                // another profile's (OSK-12117).
+                detail: `The daemon descriptor ${mismatchedPath ?? ''} is for ${mismatchedBootstrap.serverUrl}, not ${opts.baseURL}.`,
                 daemonServerUrl: mismatchedBootstrap.serverUrl,
+                ...(mismatchedPath ? { descriptorPath: mismatchedPath } : {}),
             };
         }
         return {
@@ -415,7 +463,9 @@ async function redeemCliHandoffToken(bootstrap, opts = {}) {
     const abortTimer = setTimeout(() => controller.abort(), timeoutMs);
     let response;
     try {
-        response = await fetch(url, {
+        // The descriptor secret is a loopback-only credential: never `fetch`, which
+        // sends 127.0.0.1 to HTTP_PROXY under Bun and NODE_USE_ENV_PROXY (OSK-12134).
+        response = await (0, loopback_http_1.loopbackFetch)(url, {
             method: 'POST',
             headers: {
                 Authorization: `Bearer ${bootstrap.secret}`,
@@ -497,7 +547,9 @@ async function mintRefreshFamilyThrough(bootstrap, opts) {
     const abortTimer = setTimeout(() => controller.abort(), timeoutMs);
     let response;
     try {
-        response = await fetch(url, {
+        // The descriptor secret is a loopback-only credential: never `fetch`, which
+        // sends 127.0.0.1 to HTTP_PROXY under Bun and NODE_USE_ENV_PROXY (OSK-12134).
+        response = await (0, loopback_http_1.loopbackFetch)(url, {
             method: 'POST',
             headers: {
                 Authorization: `Bearer ${bootstrap.secret}`,

package/dist/lib/delegated-cli.js

@@ -49,6 +49,7 @@ const fs = __importStar(require("node:fs"));
 const os = __importStar(require("node:os"));
 const path = __importStar(require("node:path"));
 const auth_core_1 = require("@skrr-ai/auth-core");
+const loopback_http_1 = require("@skrr-ai/auth-core/loopback-http");
 function isDelegatedCliSession(env = process.env) {
     return Boolean(env.OVERSKY_AUTONOMOUS_SESSION === '1' &&
         env.OVERSKY_DELEGATED_CLI_BROKER_URL?.trim() &&
@@ -213,7 +214,9 @@ async function fetchDelegatedCliCredential(env = process.env, options = {}) {
     try {
         let res;
         try {
-            res = await fetch(brokerUrl, {
+            // Proxy-free and loopback-only (OSK-12134): the capability and the
+            // credential it returns must never reach HTTP_PROXY.
+            res = await (0, loopback_http_1.loopbackFetch)(brokerUrl, {
                 method: 'POST',
                 headers: { Accept: 'application/json', 'Content-Type': 'application/json' },
                 body: JSON.stringify({

package/dist/lib/exec-runtime-binary.d.ts

@@ -71,7 +71,9 @@ export declare function notInstalledMessage(): string;
  * preserving "exit code = the daemon's exit code" semantics that scripts
  * may depend on.
  */
-export declare function execRuntimeBinary(args: string[]): Promise<number>;
+export declare function execRuntimeBinary(args: string[], opts?: {
+    binary?: string;
+}): Promise<number>;
 /** Output from a short-lived runtime probe such as `skrrd status --json`. */
 export type RuntimeBinaryOutput = {
     code: number;

package/dist/lib/exec-runtime-binary.js

@@ -212,9 +212,11 @@ function notInstalledMessage() {
  * preserving "exit code = the daemon's exit code" semantics that scripts
  * may depend on.
  */
-function execRuntimeBinary(args) {
+function execRuntimeBinary(args, opts = {}) {
     return new Promise((resolve, reject) => {
-        const bin = findRuntimeBinary();
+        // `binary` lets `status` render from the LIVE daemon's program rather than
+        // the first one on PATH (OSK-12102); every other verb forwards to PATH.
+        const bin = opts.binary ?? findRuntimeBinary();
         if (!bin) {
             reject(new Error('runtime-binary-not-installed'));
             return;

package/dist/lib/first-party-harness-broker.js

@@ -259,7 +259,10 @@ async function acquireManagedSession(input = {}, deps = {}) {
                 sessionToken,
                 model: input.model?.trim() || AUTOMATIC_MODEL,
                 localRuntimeId: (deps.localRuntimeId ?? localRuntimeId)(),
-                machineUuid: (deps.machineUuid ?? auth_core_1.ensureMachineDaemonId)(),
+                // The hardware id every Daemon row is keyed on — the same function
+                // the daemon calls — not the minted `~/.skrr/daemon.id` UUIDv7,
+                // so the reservation's attribution joins to this machine (OSK-12063).
+                machineUuid: (deps.machineUuid ?? auth_core_1.getMachineUuid)(),
             }, fetchImpl, acquisition.signal);
         }
         catch (err) {

package/dist/lib/harnesses.d.ts

@@ -64,6 +64,16 @@ export interface Harness {
     version?: number;
     claudeEngine?: 'cli' | 'sdk';
     lastSeenAt?: string;
+    /** This harness's own stored permission-mode fallback, when set. */
+    defaultPermissionMode?: string | null;
+    /**
+     * The permission modes this harness can honour, and where the answer came
+     * from — sent by `GET /api/harnesses/:id` for a local row (OSK-12130).
+     */
+    permissionModes?: {
+        modes: string[];
+        source: 'daemon' | 'daemon_record' | 'static' | 'vocabulary' | string;
+    };
     /**
      * Registration metadata. A managed machine's rows carry `machineProduct` and
      * `machineLeaseId`, which is the only link from a lease to the harness rows its

package/dist/lib/live-runtime-binary.d.ts

@@ -0,0 +1,40 @@
+export interface LiveProgram {
+    /** The executable the OS reports for the live pid. */
+    exec: string;
+    /** For an interpreter-launched daemon, the script it runs. */
+    script: string | null;
+}
+export interface LiveRuntimeDeps {
+    /** pid of the live daemon for `profile`, or null. */
+    livePid(profile: string): number | null;
+    /** The live pid's program, or null when the OS will not say. */
+    programOf(pid: number): LiveProgram | null;
+    realpath(p: string): string;
+    isExecutable(p: string): boolean;
+}
+export type StatusBinaryDecision = {
+    kind: 'same';
+    binary: string;
+} | {
+    kind: 'unknown';
+    binary: string;
+} | {
+    kind: 'forward-live';
+    binary: string;
+    pathBinary: string;
+} | {
+    kind: 'mismatch';
+    binary: string;
+    live: string;
+};
+/** The profile a forwarded argv names, `default` otherwise. */
+export declare function profileFromArgs(args: readonly string[]): string;
+/**
+ * Decide which binary renders `status`. Never throws: a probe that cannot
+ * answer leaves the PATH binary in place (`unknown`).
+ */
+export declare function decideStatusBinary(pathBinary: string, profile: string, deps: LiveRuntimeDeps): StatusBinaryDecision;
+/** One stderr line naming the binary that rendered status, when it is not obvious. */
+export declare function describeStatusBinary(decision: StatusBinaryDecision): string | null;
+export declare function scriptFromArgs(exec: string, args: string): string | null;
+export declare function defaultLiveRuntimeDeps(): LiveRuntimeDeps;

package/dist/lib/live-runtime-binary.js

@@ -0,0 +1,193 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.profileFromArgs = profileFromArgs;
+exports.decideStatusBinary = decideStatusBinary;
+exports.describeStatusBinary = describeStatusBinary;
+exports.scriptFromArgs = scriptFromArgs;
+exports.defaultLiveRuntimeDeps = defaultLiveRuntimeDeps;
+/**
+ * Which runtime binary is the LIVE daemon running, and is it the one
+ * `skrr daemon status` is about to forward to? (OSK-12102)
+ *
+ * `execRuntimeBinary` forwards to the first `skrrd` on PATH. That is right for
+ * lifecycle verbs, where PATH order is the person's choice of install. It is
+ * wrong for `status`, whose whole subject is the daemon that is running: with
+ * an old dev build early on PATH and the release daemon live, the header named
+ * `.../releases/0.8.62/skrrd` while the body was rendered by the dev build —
+ * its old layout, no per-category permission table — and nothing on screen
+ * said two binaries were involved.
+ *
+ * The live daemon's pid comes from its island bootstrap file (the same
+ * discovery the CLI's login broker uses); the program from the OS. When the
+ * live program is itself a runtime executable, status is forwarded to it.
+ * When it cannot be exec'd directly (a `node .../dist/index.js` dev daemon),
+ * status stays on the PATH binary and says so.
+ */
+const node_child_process_1 = require("node:child_process");
+const node_fs_1 = require("node:fs");
+const node_path_1 = __importDefault(require("node:path"));
+const daemonBroker_1 = require("./daemonBroker");
+const exec_runtime_binary_1 = require("./exec-runtime-binary");
+function safeRealpath(deps, p) {
+    try {
+        return deps.realpath(p);
+    }
+    catch {
+        return p;
+    }
+}
+function isRuntimeName(p) {
+    const base = node_path_1.default
+        .basename(p)
+        .toLowerCase()
+        .replace(/\.(exe|cmd)$/, '');
+    return exec_runtime_binary_1.RUNTIME_BINARY_NAMES.some((name) => base === name || base.startsWith(`${name}-`));
+}
+/** The profile a forwarded argv names, `default` otherwise. */
+function profileFromArgs(args) {
+    for (let i = 0; i < args.length; i += 1) {
+        const arg = args[i];
+        if (arg === '--')
+            break;
+        if (arg === '--profile' && args[i + 1] && !args[i + 1].startsWith('-'))
+            return args[i + 1];
+        if (arg.startsWith('--profile=') && arg.length > '--profile='.length) {
+            return arg.slice('--profile='.length);
+        }
+    }
+    return 'default';
+}
+/**
+ * Decide which binary renders `status`. Never throws: a probe that cannot
+ * answer leaves the PATH binary in place (`unknown`).
+ */
+function decideStatusBinary(pathBinary, profile, deps) {
+    let program = null;
+    try {
+        const pid = deps.livePid(profile);
+        program = pid ? deps.programOf(pid) : null;
+    }
+    catch {
+        program = null;
+    }
+    if (!program)
+        return { kind: 'unknown', binary: pathBinary };
+    const pathReal = safeRealpath(deps, pathBinary);
+    const execReal = safeRealpath(deps, program.exec);
+    const scriptReal = program.script ? safeRealpath(deps, program.script) : null;
+    if (pathReal === execReal || (scriptReal !== null && pathReal === scriptReal)) {
+        return { kind: 'same', binary: pathBinary };
+    }
+    // Only a runtime executable is forwarded to. A `node`/Electron-hosted daemon
+    // has an interpreter as its exec, and running the interpreter with status
+    // argv would be nonsense.
+    const directlyRunnable = program.script === null &&
+        (isRuntimeName(program.exec) || isRuntimeName(execReal)) &&
+        deps.isExecutable(program.exec);
+    if (directlyRunnable) {
+        return { kind: 'forward-live', binary: program.exec, pathBinary };
+    }
+    return { kind: 'mismatch', binary: pathBinary, live: program.script ?? program.exec };
+}
+/** One stderr line naming the binary that rendered status, when it is not obvious. */
+function describeStatusBinary(decision) {
+    switch (decision.kind) {
+        case 'forward-live':
+            return (`Rendered by the live daemon's binary ${decision.binary} ` +
+                `(the first skrrd on PATH is ${decision.pathBinary}, a different build).`);
+        case 'mismatch':
+            return (`Rendered by ${decision.binary}, the first skrrd on PATH — NOT the live daemon's ` +
+                `program (${decision.live}). This layout and these checks are that build's, not the live one's.`);
+        default:
+            return null;
+    }
+}
+function darwinProgramOf(pid) {
+    const out = (args) => (0, node_child_process_1.execFileSync)('ps', ['-p', String(pid), '-o', ...args], {
+        encoding: 'utf8',
+        timeout: 2_000,
+        stdio: ['ignore', 'pipe', 'ignore'],
+    }).trim();
+    const exec = out(['comm=']);
+    if (!exec || !node_path_1.default.isAbsolute(exec))
+        return null;
+    return { exec, script: scriptFromArgs(exec, out(['args='])) };
+}
+function linuxProgramOf(pid) {
+    const exec = (0, node_fs_1.readlinkSync)(`/proc/${pid}/exe`);
+    let script = null;
+    try {
+        const cmdline = (0, node_fs_1.readFileSync)(`/proc/${pid}/cmdline`, 'utf8');
+        script = scriptFromArgs(exec, cmdline.split('\0').filter(Boolean).join(' '));
+    }
+    catch {
+        script = null;
+    }
+    return { exec, script };
+}
+/**
+ * For an interpreter-hosted daemon (`node --import x.mjs /x/dist/index.js
+ * start …`), the script: the first argument after the exec that is neither an
+ * option nor the value of a module-loading option. `ps -o args=` is
+ * space-joined, so a path containing a space is not recovered — the result is
+ * only ever used for display and an equality check, where a miss degrades to
+ * the "mismatch" note rather than to a wrong forward.
+ */
+const INTERPRETER_VALUE_OPTIONS = new Set([
+    '-r',
+    '--require',
+    '--import',
+    '--loader',
+    '--experimental-loader',
+    '-e',
+    '--eval',
+]);
+function scriptFromArgs(exec, args) {
+    if (isRuntimeName(exec))
+        return null;
+    const rest = args.startsWith(exec) ? args.slice(exec.length) : args.replace(/^\S+/, '');
+    const tokens = rest.split(/\s+/).filter(Boolean);
+    for (let i = 0; i < tokens.length; i += 1) {
+        const token = tokens[i];
+        if (INTERPRETER_VALUE_OPTIONS.has(token)) {
+            i += 1;
+            continue;
+        }
+        if (token.startsWith('-'))
+            continue;
+        return token;
+    }
+    return null;
+}
+function defaultLiveRuntimeDeps() {
+    return {
+        livePid(profile) {
+            for (const candidate of (0, daemonBroker_1.resolveExactProfileBootstrapPaths)(profile)) {
+                const bootstrap = (0, daemonBroker_1.readBootstrap)(candidate);
+                if (typeof bootstrap?.pid === 'number' && bootstrap.pid > 0)
+                    return bootstrap.pid;
+            }
+            return null;
+        },
+        programOf(pid) {
+            if (process.platform === 'darwin')
+                return darwinProgramOf(pid);
+            if (process.platform === 'linux')
+                return linuxProgramOf(pid);
+            return null;
+        },
+        realpath: (p) => (0, node_fs_1.realpathSync)(p),
+        isExecutable(p) {
+            try {
+                (0, node_fs_1.accessSync)(p, node_fs_1.constants.X_OK);
+                return true;
+            }
+            catch {
+                return false;
+            }
+        },
+    };
+}