@floh-solutions/pharos-cli 0.33.0 → 0.35.0

package/dist/commands/delegate.js

@@ -1,11 +1,12 @@
 import { execFile } from "node:child_process";
 import { realpath, stat } from "node:fs/promises";
+import { homedir } from "node:os";
 import { basename, isAbsolute, join } from "node:path";
 import { promisify } from "node:util";
 import { findApp, HOSTS, HOST_IDS, AGENT_IDS, MODES, isAgentId, isHostId, isMode, } from "../delegate/hosts.js";
 import { ARGUS_NEW_WORKER, ARGUS_REASONS, ARGUS_TEXT_LIMIT, ARGUS_WAIT_SECONDS, ArgusUnreachableError, askArgus, candidatesSupport, delegateCandidatesRequest, delegateRequest, delegateStatusRequest, fleetStatusRequest, isFailure, mapRefusal, parseCandidates, parseFleet, rankWorkers, readDelegation, readTimeoutMs, systemArgusDeps, unreachable, } from "../delegate/argus.js";
 import { asTypedInput, LAUNCH_SCRIPT, launchCommand, SEND_TO_TAB_SCRIPT } from "../delegate/quote.js";
-import { findSessions, rankSessions, systemProbes, } from "../delegate/sessions.js";
+import { carriedSentence, findSessions, rankSessions, systemProbes, } from "../delegate/sessions.js";
 import { BRIDGE_EXTENSION_ID, bridgeAtLeast, bundledBridge, bundledVsixPath, CLAUDE_EXTENSION_ID, extensionsDirectory, installBridge, installedExtensions, SESSION_BRIDGE_VERSION, } from "../delegate/vsix.js";
 import { CliError, EXIT_FAILED, EXIT_USAGE, emit, emitText, usageError } from "../output.js";
 import { resolveOnPath } from "./doctor.js";
@@ -55,6 +56,17 @@ export const REASONS = [
  * whenever it gets to it rather than in lockstep with this release.
  */
 export const CAUSES = ["stale-window"];
+/**
+ * `--host all`: ask every installed host, in one listing. `--list` only.
+ *
+ * Spelled as a `--host` value rather than as a missing `--host`, on purpose:
+ * `--host` stays required everywhere, and a pharos that predates this refuses
+ * `all` with a usage error naming the four it knows — which is exactly the
+ * signal an app built against this one needs to fall back to asking one host.
+ * A missing flag meaning "every host" would have been accepted by nobody and
+ * silently misread by nothing, which is worse.
+ */
+export const ALL_HOSTS = "all";
 export const SYSTEM_DEPS = {
     findApp,
     resolveOnPath,
@@ -216,6 +228,9 @@ export function ghAccountOption(value) {
     return given;
 }
 export async function runDelegate(io, env, options, deps = SYSTEM_DEPS) {
+    // Before the one-host parse, which would refuse the word — see ALL_HOSTS.
+    if ((options.host ?? "").trim() === ALL_HOSTS)
+        return runAcrossHosts(io, env, options, deps);
     const host = oneOf(options.host, "--host", HOST_IDS, isHostId);
     const agent = oneOf(options.agent, "--agent", AGENT_IDS, isAgentId);
     const mode = options.mode === undefined ? "terminal" : oneOf(options.mode, "--mode", MODES, isMode);
@@ -258,12 +273,7 @@ export async function runDelegate(io, env, options, deps = SYSTEM_DEPS) {
     if (text === "" && !options.list && !asking) {
         throw usageError("Nothing to send. Pass the prompt with --text, --file or --stdin.");
     }
-    const folder = (options.folder ?? "").trim();
-    if (folder === "")
-        throw usageError("--folder is required: the absolute path of the project folder.");
-    if (!isAbsolute(folder)) {
-        throw usageError(`--folder must be absolute, got ${JSON.stringify(folder)}.`, { folder });
-    }
+    const folder = folderOption(options.folder);
     const base = { host, agent, mode, folder };
     /**
      * What `--gh-account` did on a host that cannot honour it: nothing, said out
@@ -304,17 +314,11 @@ export async function runDelegate(io, env, options, deps = SYSTEM_DEPS) {
         return navarchStatus(io, env, status, base, deps, refuse, succeed);
     // Cheapest fact first: nothing else is worth asking about a folder that is
     // not there, and it is the one refusal that is entirely the caller's to fix.
-    const info = await stat(folder).catch(() => null);
-    if (info === null || !info.isDirectory()) {
-        return refuse("folder-missing", `${folder} is not a directory on this machine. The linked folder for this project has moved `
-            + "or was never here — pick it again in Settings ▸ Agents.");
-    }
+    if (!(await isFolder(folder)))
+        return refuse("folder-missing", folderMissing(folder));
     const app = await deps.findApp(host, env);
-    if (app === null) {
-        return refuse("host-not-installed", `${HOSTS[host].name} is not installed — looked up by bundle id ${HOSTS[host].bundleId} through `
-            + "Spotlight and at the usual paths under /Applications and ~/Applications."
-            + (HOSTS[host].cask === undefined ? "" : ` \`brew install --cask ${HOSTS[host].cask}\` installs it.`));
-    }
+    if (app === null)
+        return refuse("host-not-installed", hostNotInstalled(host));
     // **Navarch takes both verbs before the agent is even resolved**, and that
     // is not an oversight. Nothing here runs the agent: argusd spawns a worker
     // through Navarch, from the app's own login shell and its own PATH. A
@@ -366,25 +370,260 @@ async function listSessions(io, host, agent, mode, folder, agentPath, env, deps,
     if (agent === "claude" ? probePath === null : agentPath === null) {
         return refuse("agent-not-installed", agentNotInstalled(agent, env));
     }
-    const { sessions, incomplete, detail: probeDetail } = await findSessions(agent, folder, deps.probes(env, probePath));
-    const ranked = rankSessions(sessions, host);
-    const rows = ranked.map((session, index) => toRow(session, index === 0));
+    const { sessions, incomplete, detail: probeDetail, carried } = await findSessions(agent, folder, deps.probes(env, probePath));
+    const rows = hostRows(sessions, host);
+    // The list is also where somebody chooses "Start a … Session", so a host
+    // that would start it as another login says so here, before the choice.
+    const detail = listSentence(rows, agent, host, folder, incomplete, probeDetail) + carriedNote(carried, host, env);
+    const listing = { ok: true, host, agent, mode, folder, sessions: rows, incomplete, detail };
+    if (!pretty)
+        return emit(io, listing);
+    return emitText(io, [detail, ...rows.map(prettyRow)].join("\n"));
+}
+/** One host's rows, in its pick order, `recommended` on the head — the ONE ranking. */
+function hostRows(sessions, host) {
+    return rankSessions(sessions, host).map((session, index) => toRow(session, index === 0));
+}
+/** What a one-host listing says — also each pid host's entry in a `--host all` listing. */
+function listSentence(rows, agent, host, folder, incomplete, probeDetail) {
     const agentName = nameOf(agent);
     const where = `${HOSTS[host].name} on ${folder}`;
     const core = rows.length === 0
         ? `No ${agentName} session is running in ${where}.`
         : `${rows.length} ${agentName} session${rows.length === 1 ? "" : "s"} in ${where}. A plain delegate `
             + `would use ${rows[0].name} (${rows[0].status}).`;
-    const detail = incomplete
+    return incomplete
         ? `${core} Detection was incomplete (${probeDetail ?? "a probe failed"}), so this list may be short.`
         : core;
-    const listing = { ok: true, host, agent, mode, folder, sessions: rows, incomplete, detail };
-    if (!pretty)
+}
+/** One row of `--pretty`: the star on the row a plain delegate to its host would take. */
+function prettyRow(row) {
+    return `${row.recommended ? "*" : " "} ${row.id}  ${row.name} — ${row.status}, ${row.detail}`;
+}
+// MARK: - Every host at once (#1401)
+/**
+ * `--list --host all` — the validation, the two refusals that are about the
+ * whole question, and the answer.
+ *
+ * **Only `--list`.** A send has to go somewhere, and "every host" is not a
+ * somewhere: a `--session` id is a pid or a worker uuid that exists in exactly
+ * one host, `--session new` needs the host to start in, and `--status` is a
+ * Navarch question. So each of those, with `all`, is a usage error naming what
+ * to pass instead — never a guess at which host was meant.
+ *
+ * **It refuses only where no host could be asked** — the folder is missing,
+ * nothing is installed, or every installed host refused for the same reason
+ * (`claude` is on no PATH and no VS Code carries the extension). Then the
+ * answer IS that reason, and it is the one a one-host call would have given.
+ * Anything short of that is `ok: true` with the rows there are, and each host
+ * that contributed none says why in `hosts` — a Navarch whose argusd is down is
+ * no reason to hide the Terminal session beside it.
+ */
+async function runAcrossHosts(io, env, options, deps) {
+    const agent = oneOf(options.agent, "--agent", AGENT_IDS, isAgentId);
+    // Accepted for its shape and otherwise unread: a listing does not depend on
+    // the door a prompt would go through, and `extension` is a real value for
+    // the VS Code hosts among the ones asked.
+    const mode = options.mode === undefined ? "terminal" : oneOf(options.mode, "--mode", MODES, isMode);
+    if (!options.list || options.session !== undefined || options.status !== undefined) {
+        throw usageError(`--host ${ALL_HOSTS} asks every host what is running, so it goes with --list and nothing else. A send, `
+            + "a --session pick and a --status read each go to ONE host: pass the row's own `host` with its "
+            + "`--session` id, and the host a new session should start in otherwise.", { host: ALL_HOSTS });
+    }
+    // Shape only, as on every `--list`: a list starts nothing to bind it to.
+    ghAccountOption(options.ghAccount);
+    const folder = folderOption(options.folder);
+    const base = { host: ALL_HOSTS, agent, mode, folder };
+    const refuse = (reason, detail) => emitRefusal(io, options.pretty, { ok: false, reason, detail, ...base });
+    if (!(await isFolder(folder)))
+        return refuse("folder-missing", folderMissing(folder));
+    const answers = await listAcrossHosts(agent, folder, env, deps);
+    const asked = answers.filter((answer) => answer.listing.reason !== "host-not-installed");
+    if (asked.length === 0) {
+        return refuse("host-not-installed", `None of the hosts is installed — ${HOST_IDS.map((host) => HOSTS[host].name).join(", ")} were each `
+            + "looked up by bundle id through Spotlight and at the usual paths under /Applications and "
+            + "~/Applications.");
+    }
+    const reasons = new Set(asked.map((answer) => answer.listing.reason));
+    const only = asked[0].listing;
+    if (reasons.size === 1 && only.reason !== undefined)
+        return refuse(only.reason, only.detail);
+    const sessions = answers.flatMap((answer) => answer.rows);
+    const hosts = answers.map((answer) => answer.listing);
+    const source = hosts.find((entry) => entry.source !== undefined)?.source;
+    const listing = {
+        ok: true,
+        ...base,
+        sessions,
+        incomplete: hosts.some((entry) => entry.incomplete),
+        ...(source === undefined ? {} : { source }),
+        detail: acrossHostsDetail(hosts, agent, folder),
+        hosts,
+    };
+    if (!options.pretty)
         return emit(io, listing);
-    return emitText(io, [
-        detail,
-        ...rows.map((row) => `${row.recommended ? "*" : " "} ${row.id}  ${row.name} — ${row.status}, ${row.detail}`),
-    ].join("\n"));
+    return emitText(io, [listing.detail, ...sessions.map(prettyRow)].join("\n"));
+}
+/**
+ * Every host's `--list`, in {@link HOST_IDS} order, each exactly as it would
+ * have answered alone — and never more expensive than it has to be.
+ *
+ * - **One detection for the three pid hosts.** `claude agents --json` and `ps`
+ *   see the whole machine whichever host asked, and {@link rankSessions}
+ *   filters by host afterwards — so asking once and ranking three times is the
+ *   same answer as three calls, for a third of the processes.
+ * - **The Navarch read beside it, not after it.** It is a socket round trip
+ *   that shares nothing with the detection, so the two run at once.
+ * - **The installed check first**, for all four at once: a host nobody has
+ *   installed is not asked anything, as it is not on its own.
+ */
+async function listAcrossHosts(agent, folder, env, deps) {
+    const [apps, agentPath] = await Promise.all([
+        Promise.all(HOST_IDS.map((host) => deps.findApp(host, env))),
+        deps.resolveOnPath(agent, env),
+    ]);
+    const installed = new Set(HOST_IDS.filter((_, index) => apps[index] !== null));
+    const pidHosts = HOST_IDS.filter((host) => host !== "navarch" && installed.has(host));
+    const [pid, navarch] = await Promise.all([
+        listPidHosts(agent, folder, agentPath, pidHosts, env, deps),
+        installed.has("navarch") ? listNavarchHost(agent, folder, env, deps) : null,
+    ]);
+    return HOST_IDS.map((host) => {
+        if (!installed.has(host))
+            return refusedHost(host, "host-not-installed", hostNotInstalled(host));
+        const answer = host === "navarch" ? navarch : pid.get(host);
+        // Unreachable: every installed host was handed to exactly one of the two.
+        return answer ?? refusedHost(host, "unsupported", `${HOSTS[host].name} was not asked.`);
+    });
+}
+/**
+ * Terminal and the two VS Codes, from one detection — each gated the way
+ * {@link listSessions} gates it alone.
+ *
+ * The gate is the agent: the list is `claude agents --json` (or `ps` for
+ * Codex) and a host whose own call would refuse `agent-not-installed` is
+ * reported so rather than listed. Claude off PATH is the one case where hosts
+ * differ: a VS Code whose Claude Code extension carries its own `claude` lists
+ * through that binary, and Terminal has nothing to fall back on. Whichever
+ * binary asks, the registries are the machine's — so the detection runs once,
+ * with the first `claude` there is.
+ */
+async function listPidHosts(agent, folder, agentPath, hosts, env, deps) {
+    const answers = new Map();
+    const listable = [];
+    let probePath = agent === "claude" ? agentPath : null;
+    for (const host of hosts) {
+        if (agentPath !== null) {
+            listable.push(host);
+            continue;
+        }
+        if (agent === "claude" && HOSTS[host].vscode !== undefined) {
+            const extensions = await deps.installedExtensions(host, env);
+            const bundled = bundledClaude(extensions?.find((extension) => extension.id === CLAUDE_EXTENSION_ID));
+            if (bundled !== null) {
+                listable.push(host);
+                probePath ??= bundled;
+                continue;
+            }
+        }
+        answers.set(host, refusedHost(host, "agent-not-installed", agentNotInstalled(agent, env)));
+    }
+    if (listable.length === 0)
+        return answers;
+    const { sessions, incomplete, detail: probeDetail, carried } = await findSessions(agent, folder, deps.probes(env, probePath));
+    for (const host of listable) {
+        const rows = hostRows(sessions, host);
+        answers.set(host, {
+            rows,
+            listing: {
+                host,
+                sessions: rows.length,
+                incomplete,
+                detail: listSentence(rows, agent, host, folder, incomplete, probeDetail) + carriedNote(carried, host, env),
+            },
+        });
+    }
+    return answers;
+}
+/**
+ * Navarch's part: `delegate_candidates`, with the `fleet_status` fallback, as
+ * `--list --host navarch` reads it — and what would have been a refusal or a
+ * failure there folded into the entry instead.
+ *
+ * Three shapes, and they differ on `incomplete` for a reason:
+ *
+ * - **the socket refused** (`argusd-outdated`, `navarch-not-running`, …) — a
+ *   definite answer that nothing here can be delivered to, so not incomplete;
+ * - **nothing listening** — `argusd-not-running`, and not incomplete either:
+ *   argusd is what holds a worker's terminal, so with no argusd there is no
+ *   worker to have missed;
+ * - **the conversation broke** — a park that outlived its deadline, a line
+ *   that is not JSON. That is "could not tell", which is exactly what
+ *   `incomplete` is for; alone it is the CLI's exit-1 failure.
+ */
+async function listNavarchHost(agent, folder, env, deps) {
+    try {
+        const found = await navarchCandidates(deps.argus(env), agent, await canonicalFolder(folder));
+        if (isFailure(found))
+            return refusedHost("navarch", found.reason, found.detail);
+        const rows = rowsOf(found.workers, agent, found.target);
+        return {
+            rows,
+            listing: {
+                host: "navarch",
+                sessions: rows.length,
+                incomplete: false,
+                detail: navarchListDetail(rows, agent, folder, found.source),
+                source: found.source,
+            },
+        };
+    }
+    catch (error) {
+        if (error instanceof ArgusUnreachableError) {
+            const failure = unreachable(error);
+            return refusedHost("navarch", failure.reason, failure.detail);
+        }
+        return {
+            rows: [],
+            listing: {
+                host: "navarch",
+                sessions: 0,
+                incomplete: true,
+                detail: `The Argus socket did not answer, so Navarch's workers could not be listed: ${messageOf(error)}`,
+            },
+        };
+    }
+}
+/** A host that contributed nothing, with the reason its own `--list` would have refused with. */
+function refusedHost(host, reason, detail) {
+    return { rows: [], listing: { host, sessions: 0, incomplete: false, reason, detail } };
+}
+/**
+ * The listing's own sentence: how many, where, and which hosts said nothing
+ * useful and why.
+ *
+ * A host that is **not installed** is left out of it — on most machines that
+ * is two of the four, it is not news, and `hosts` still carries it. A host that
+ * IS installed and could not be listed is named with its reason id, because
+ * that is a fix somebody may want to make; the full prose is on its entry.
+ */
+function acrossHostsDetail(hosts, agent, folder) {
+    const agentName = nameOf(agent);
+    const total = hosts.reduce((sum, entry) => sum + entry.sessions, 0);
+    const counts = hosts
+        .filter((entry) => entry.sessions > 0)
+        .map((entry) => `${entry.sessions} in ${HOSTS[entry.host].name}`);
+    const head = total === 0
+        ? `No ${agentName} session is running on ${folder} in any host that could be asked.`
+        : `${total} ${agentName} session${total === 1 ? "" : "s"} on ${folder}: ${counts.join(", ")}. Each host's `
+            + "first row is the one a plain delegate to that host would use.";
+    const refused = hosts
+        .filter((entry) => entry.reason !== undefined && entry.reason !== "host-not-installed")
+        .map((entry) => `${HOSTS[entry.host].name} (${entry.reason})`);
+    const short = hosts.filter((entry) => entry.incomplete).map((entry) => HOSTS[entry.host].name);
+    return (head
+        + (refused.length === 0 ? "" : ` Not listed: ${refused.join(", ")}.`)
+        + (short.length === 0 ? "" : ` Detection was incomplete for ${short.join(", ")}, so the list may be short there.`));
 }
 /** The `claude` the Claude Code extension carries, at the path measured on 2.1.228. */
 function bundledClaude(claudeExt) {
@@ -394,18 +633,35 @@ function bundledClaude(claudeExt) {
 function toRow(session, recommended) {
     // `rankSessions` filtered on the host, so it is never null here.
     const host = session.host;
+    const where = host === "terminal"
+        ? session.tty === null ? "Terminal" : `Terminal tab ${basename(session.tty)}`
+        : HOSTS[host].name;
     return {
         id: String(session.pid),
         name: displayName(session),
         agent: session.agent,
         host,
         status: session.status ?? "unknown",
-        detail: host === "terminal"
-            ? session.tty === null ? "Terminal" : `Terminal tab ${basename(session.tty)}`
-            : HOSTS[host].name,
+        // Still a LOCATOR: where the session is, and — when it is not the
+        // default — which login it runs as. Never the status.
+        detail: session.profile === undefined ? where : `${where} · profile ${session.profile}`,
         recommended,
+        ...(session.profile === undefined ? {} : { profile: session.profile }),
     };
 }
+/**
+ * The sentence for a host that would START a Claude session as another login,
+ * with its leading space — or nothing when it would not.
+ *
+ * Only ever about the host being asked: a note that VS Code carries a profile
+ * is noise on a Terminal delegation. Starting a session is deliberately
+ * unchanged (#1431 ▸ 3) — the host's own environment decides the account, as
+ * it always did — so this reports rather than corrects.
+ */
+function carriedNote(carried, host, env) {
+    const mine = carried.find((entry) => entry.host === host);
+    return mine === undefined ? "" : ` ${carriedSentence(mine, env["HOME"] ?? homedir())}`;
+}
 /**
  * What to call a session in a menu.
  *
@@ -666,12 +922,31 @@ function dryRunDetail(picked, pick, ranked, agent, folder, ghAccount, source) {
 /** The inventory, in the shape every host answers `--list` in. */
 function emitNavarchList(io, base, agent, found, pretty) {
     const rows = rowsOf(found.workers, agent, found.target);
+    const detail = navarchListDetail(rows, agent, base.folder, found.source);
+    // **`incomplete` is false and means it.** Every other host infers the list
+    // from `ps` and a probe that can fail; both reads here are the daemon's own
+    // register of what it is running, so a short answer is an answer and not a
+    // gap.
+    const listing = {
+        ok: true,
+        ...base,
+        sessions: rows,
+        incomplete: false,
+        source: found.source,
+        detail,
+    };
+    if (!pretty)
+        return emit(io, listing);
+    return emitText(io, [detail, ...rows.map(prettyRow)].join("\n"));
+}
+/** What a Navarch listing says — alone, and as Navarch's entry in a `--host all` one. */
+function navarchListDetail(rows, agent, folder, source) {
     const agentName = nameOf(agent);
     const head = rows.length === 0
-        ? `No ${agentName} worker is free in Navarch on ${base.folder}. A delegation would start one. `
+        ? `No ${agentName} worker is free in Navarch on ${folder}. A delegation would start one. `
             + "A worker holding a board mission, and an Argus Agent, are running agents that are "
             + "deliberately not candidates — so this can read empty with panes open on that folder."
-        : `${rows.length} ${agentName} worker${rows.length === 1 ? "" : "s"} in Navarch on ${base.folder}. `
+        : `${rows.length} ${agentName} worker${rows.length === 1 ? "" : "s"} in Navarch on ${folder}. `
             + `A plain delegate would use ${(rows.find((row) => row.recommended) ?? rows[0]).name} `
             + `(${(rows.find((row) => row.recommended) ?? rows[0]).status}).`;
     // **Which side answered, in the list's own prose as well as in `source`.**
@@ -679,32 +954,14 @@ function emitNavarchList(io, base, agent, found, pretty) {
     // accept, the other is what this CLI predicts it would — and on the older
     // daemon the pick a caller makes from it cannot be honoured at all, which is
     // the thing a person reading the list needs to know BEFORE they pick.
-    const provenance = found.source === "daemon"
+    const provenance = source === "daemon"
         ? " argusd answered this list itself (`delegate_candidates`), so a row here is a row it accepts:"
             + " `--session` takes any of these ids."
         : " This argusd predates `delegate_candidates` (argus #1402), so the list is this CLI's own"
             + " reading of `fleet_status` and a prediction of the daemon's find. `--session` and"
             + " `--gh-account` are refused `argusd-outdated` against it — reloading argusd is what lifts"
             + " that, and it ends every live worker session.";
-    const detail = head + provenance;
-    // **`incomplete` is false and means it.** Every other host infers the list
-    // from `ps` and a probe that can fail; both reads here are the daemon's own
-    // register of what it is running, so a short answer is an answer and not a
-    // gap.
-    const listing = {
-        ok: true,
-        ...base,
-        sessions: rows,
-        incomplete: false,
-        source: found.source,
-        detail,
-    };
-    if (!pretty)
-        return emit(io, listing);
-    return emitText(io, [
-        detail,
-        ...rows.map((row) => `${row.recommended ? "*" : " "} ${row.id}  ${row.name} — ${row.status}, ${row.detail}`),
-    ].join("\n"));
+    return head + provenance;
 }
 /**
  * The rows, with `recommended` on the one the daemon would take.
@@ -849,6 +1106,31 @@ function navarchText(text) {
     }
     return text;
 }
+/** `--folder` → the path, or a usage error: it is required, and it must be absolute. */
+function folderOption(value) {
+    const folder = (value ?? "").trim();
+    if (folder === "")
+        throw usageError("--folder is required: the absolute path of the project folder.");
+    if (!isAbsolute(folder)) {
+        throw usageError(`--folder must be absolute, got ${JSON.stringify(folder)}.`, { folder });
+    }
+    return folder;
+}
+async function isFolder(folder) {
+    const info = await stat(folder).catch(() => null);
+    return info !== null && info.isDirectory();
+}
+/** The `folder-missing` detail — one place, because the one-host and every-host paths both reach it. */
+function folderMissing(folder) {
+    return (`${folder} is not a directory on this machine. The linked folder for this project has moved `
+        + "or was never here — pick it again in Settings ▸ Agents.");
+}
+/** The `host-not-installed` detail — alone a refusal, and in `--host all` that host's entry. */
+function hostNotInstalled(host) {
+    return (`${HOSTS[host].name} is not installed — looked up by bundle id ${HOSTS[host].bundleId} through `
+        + "Spotlight and at the usual paths under /Applications and ~/Applications."
+        + (HOSTS[host].cask === undefined ? "" : ` \`brew install --cask ${HOSTS[host].cask}\` installs it.`));
+}
 /** `realpath`, falling back to the path as given when it cannot be resolved. */
 async function canonicalFolder(folder) {
     try {
@@ -1030,7 +1312,7 @@ async function delegateToVsCode(host, agent, mode, folder, text, agentPath, env,
     // Detect against the bundled binary when that is the only `claude` there, so
     // the prediction still holds; the bridge does its own detection regardless.
     const probePath = agent === "claude" ? agentPath ?? bundledClaude(claudeExt) : null;
-    const { sessions, incomplete, detail: probeDetail } = await findSessions(agent, folder, deps.probes(env, probePath));
+    const { sessions, incomplete, detail: probeDetail, carried } = await findSessions(agent, folder, deps.probes(env, probePath));
     const ranked = rankSessions(sessions, host);
     // **`--session <pid>` is pre-checked here AND honoured again by the bridge,
     // and the two are independent on purpose.** The URI is one-way: nothing comes
@@ -1138,9 +1420,15 @@ async function delegateToVsCode(host, agent, mode, folder, text, agentPath, env,
     const uri = delegateUri(spec.vscode.scheme, { folder, agent, mode, text, session: pick });
     const agentName = nameOf(agent);
     const claudeExtInstalled = mode === "extension" && agent === "claude" ? claudeExt !== undefined : true;
-    // The bridge decides; this is the same detection it runs, so the prediction
-    // is honest and the wording says whose call it is. One tense throughout —
+    // The bridge decides; this is the detection it runs, so the prediction is
+    // honest and the wording says whose call it is. One tense throughout —
     // `would` in a dry run, plain past/present otherwise.
+    //
+    // One known gap in "the detection it runs" (#1436): this reads every Claude
+    // registry on the machine, and the bridge reads only the one its editor
+    // carries. They agree whenever a session's registry came from the editor —
+    // which is the measured case — and disagree only when one terminal inside
+    // it overrode `CLAUDE_CONFIG_DIR` itself.
     const hand = dryRun ? "Would hand this to" : "Handed to";
     const asked = pick?.kind !== "new"
         ? ""
@@ -1163,12 +1451,17 @@ async function delegateToVsCode(host, agent, mode, folder, text, agentPath, env,
     // sentence as-is, and "Installed the Pharos bridge 0.3.0 into VS Code
     // Insiders first." is the fact somebody needs before the one about where the
     // prompt went.
+    //
+    // A session the bridge STARTS runs in one of this editor's terminals, so it
+    // is the editor's environment that decides its login — said right after the
+    // sentence about the start, and only when there is one.
     const detail = leadNote
         + (pick?.kind === "new"
             ? `${core}${asked}`
             : session === null && incomplete
                 ? `${core} Detection was incomplete (${probeDetail ?? "a probe failed"}); a running session may exist that could not be found.`
                 : core)
+        + (session === null ? carriedNote(carried, host, env) : "")
         + tailNote;
     if (!dryRun) {
         try {
@@ -1201,8 +1494,14 @@ async function delegateToVsCode(host, agent, mode, folder, text, agentPath, env,
  * `automation-denied` with the Settings pane named.
  */
 async function delegateToTerminal(agent, folder, text, agentPath, env, deps, dryRun, pick, refuse, succeed) {
-    const { sessions, incomplete, detail: probeDetail } = await findSessions(agent, folder, deps.probes(env, agent === "claude" ? agentPath : null));
+    const { sessions, incomplete, detail: probeDetail, carried } = await findSessions(agent, folder, deps.probes(env, agent === "claude" ? agentPath : null));
     const ranked = rankSessions(sessions, "terminal");
+    // A new window's shell is started by Terminal, so it inherits Terminal's
+    // environment — and with it, the login a session started there runs as.
+    // On macOS 26 this is always empty: Terminal is a platform binary and `ps
+    // -E` is shown none of its environment (see `delegate/sessions.ts`), so it
+    // cannot be told, and nothing is said rather than a guess.
+    const startedAs = carriedNote(carried, "terminal", env);
     const rows = () => ranked.map((found, index) => toRow(found, index === 0));
     let session;
     if (pick === undefined) {
@@ -1281,12 +1580,12 @@ async function delegateToTerminal(agent, folder, text, agentPath, env, deps, dry
             session: null,
             detail: `Opened a new Terminal window in ${folder} running ${agentName} with the prompt, because the `
                 + `${agentName} session attributed to Terminal (pid ${session.pid}) holds no tab on tty `
-                + `${session.tty} that could be typed into.`,
+                + `${session.tty} that could be typed into.${startedAs}`,
         });
     }
     const opened = dryRun ? "Would open" : "Opened";
     const detail = `${opened} a new Terminal window in ${folder} running ${agentName} with the prompt.`
-        + `${askedNote}${elsewhereNote}${incompleteNote}`;
+        + `${startedAs}${askedNote}${elsewhereNote}${incompleteNote}`;
     if (dryRun) {
         return succeed({ action: "launched", session: null, detail, sessions: rows() });
     }
@@ -1326,12 +1625,24 @@ function describeStatus(session) {
     const parts = [session.status ?? "status unknown", `pid ${session.pid}`];
     if (session.tty !== null)
         parts.push(session.tty);
+    // A send is unchanged by where the session was registered — it is a pid and
+    // a tty like any other — but the person should still see which login it
+    // landed in when that is not the default.
+    if (session.profile !== undefined)
+        parts.push(`profile ${session.profile}`);
     return ` (${parts.join(", ")})`;
 }
 function report(session) {
     if (session === null)
         return null;
-    return { pid: session.pid, cwd: session.cwd, name: session.name, status: session.status, tty: session.tty };
+    return {
+        pid: session.pid,
+        cwd: session.cwd,
+        name: session.name,
+        status: session.status,
+        tty: session.tty,
+        ...(session.profile === undefined ? {} : { profile: session.profile }),
+    };
 }
 function emitOutcome(io, pretty, outcome) {
     return pretty ? emitText(io, outcome.detail) : emit(io, outcome);