premanmcp 0.10.0 → 0.10.1

package/README.md

@@ -68,9 +68,13 @@ Once linked, `connect` finishes onboarding without handing you homework:
 | Testing on push | Installs the git pre-push hook, so `git push` checks the endpoints you touched |
 
 Useful flags: `--agent cursor|claude-code|codex` skips the picker, `--project` writes
-project-local config, `--print` shows the config without writing it, `--yes` accepts every
-optional step, `--no-guide` skips all of them, and `--no-runner` / `--no-desktop` /
-`--no-integrations` / `--no-hook` skip one each.
+project-local config, `--print` shows the config without writing it, `--yes` takes every
+step's default without asking, `--no-guide` skips all of them, and `--no-runner` /
+`--no-desktop` / `--no-integrations` / `--no-hook` skip one each.
+
+`--yes` deliberately does *not* install the desktop app: that step's default is no, because
+it downloads a hundred-odd megabytes and writes to `/Applications`. Run `install-desktop`
+when you want it.
 
 In CI or any non-interactive shell, run `connect --agent <name> --api-key pm_live_…`.
 Without `--agent` there is nothing to prompt on, so `connect` prints ready-to-paste

package/bin/account.js

@@ -178,7 +178,7 @@ export async function watchCommand(commandArgs = []) {
   const integrationId = args.value("--integration", positional[1] || "");
   if (!runId || !integrationId) {
     throw new Error(
-      "usage: watch <run-id> <integration-id>  (both are shown by `preman status`)"
+      `usage: watch <run-id> <integration-id>  (both are shown by \`${cliInvocation()} status\`)`
     );
   }
 

package/bin/api_tools.js

@@ -45,7 +45,7 @@ export async function callTool(args, tool, toolArguments) {
   const token = resolveApiKey(args);
   if (!token) {
     throw new CliError(
-      "No PreMan API key. Run `preman login` or pass --api-key pm_live_...",
+      `No PreMan API key. Run \`${cliInvocation()} login\` or pass --api-key pm_live_...`,
       2,
     );
   }
@@ -110,7 +110,7 @@ export async function endpointsCommand(commandArgs) {
     if (args.has("--json-out")) return printJson(result);
     for (const line of result.instructions || []) process.stdout.write(`${line}\n`);
     process.stdout.write(
-      "\nHand this brief to your coding agent, then run `preman endpoints setup --file endpoints.json`.\n",
+      `\nHand this brief to your coding agent, then run \`${cliInvocation()} endpoints setup --file endpoints.json\`.\n`,
     );
     return undefined;
   }

package/bin/connect.js

@@ -19,7 +19,13 @@ import { callTool as callPremanTool, printTestSummary } from "./api_tools.js";
 import { installDesktopCommand } from "./desktop.js";
 import { installHook, hookStatus } from "./hook.js";
 import { MARK, awsCommand, githubCommand, slackCommand } from "./integrations.js";
-import { readRunnerState, registerRunner, runnerIsAlive, startBackground } from "./runner.js";
+import {
+  confirmRunnerOnline,
+  readRunnerState,
+  registerRunner,
+  runnerIsAlive,
+  startBackground,
+} from "./runner.js";
 import {
   apiKeyIsExplicit,
   assertOk,
@@ -34,6 +40,7 @@ import {
   LAUNCHER_ARGS,
   LAUNCHER_COMMAND,
   makeArgs,
+  pathPremanOwner,
   promptSecret,
   promptText,
   readJsonFile,
@@ -103,6 +110,29 @@ function onPath(binary) {
   return probe.status === 0;
 }
 
+/**
+ * Why this agent's CLI cannot run unattended right now, or "".
+ *
+ * Installed is not the same as usable. `cursor-agent` sits on PATH and exits 1
+ * on every `-p` run until someone signs in, which surfaced as "Cursor did not
+ * register any endpoints" and sent people looking at PreMan for an hour. Only
+ * Cursor is probed because only its CLI has a cheap non-interactive status
+ * subcommand; the others are diagnosed from their own output when they fail.
+ */
+export function agentBlocker(agentId) {
+  if (agentId !== "cursor") return "";
+  const probe = spawnSync("cursor-agent", ["status"], {
+    encoding: "utf8",
+    timeout: 15000,
+    stdio: ["ignore", "pipe", "pipe"],
+  });
+  const text = `${probe.stdout || ""}${probe.stderr || ""}`;
+  if (/not logged in|not authenticated|no active session/i.test(text)) {
+    return "cursor-agent is installed but not signed in — run `cursor-agent login`";
+  }
+  return "";
+}
+
 /** Best guess at which agent this machine actually uses, for the default pick. */
 function detectAgents() {
   const home = os.homedir();
@@ -878,8 +908,17 @@ function nextStepsBlock(agent) {
   );
 }
 
+/**
+ * Ask, or take the step's own default when nobody can answer.
+ *
+ * `--yes` returns the default rather than a blanket yes, which matters for
+ * exactly one step: the desktop app defaults to no because it downloads a
+ * hundred-odd megabytes and writes to /Applications. A blanket yes made
+ * `preman connect --yes` do that unattended, which is not what anyone means by
+ * "do not ask me questions" -- they get `preman install-desktop` for that.
+ */
 async function confirm(question, { assumeYes = false, defaultYes = true } = {}) {
-  if (assumeYes) return true;
+  if (assumeYes) return defaultYes;
   if (!process.stdin.isTTY) return false;
   const answer = (await promptText(`${question} ${defaultYes ? "[Y/n]" : "[y/N]"}: `)).toLowerCase();
   if (answer === "") return defaultYes;
@@ -951,7 +990,11 @@ async function discoverEndpoints(args, agent, serverName) {
 
     const brief = await callPremanTool(args, "discover_endpoints_from_codebase", { base_path: "." });
     const spec = headlessDiscovery(agent, serverName, brief.instructions || []);
-    if (!spec || !onPath(spec.bin)) {
+    const blocker = spec && onPath(spec.bin) ? agentBlocker(agent.id) : "";
+    if (!spec || !onPath(spec.bin) || blocker) {
+      // Say why before printing homework: "here is a brief" reads as PreMan not
+      // working, when the actual answer is one login away.
+      if (blocker) process.stdout.write(`${MARK.skip()} ${blocker}\n`);
       for (const line of brief.instructions || []) process.stdout.write(`${line}\n`);
       process.stdout.write(`\nHand this brief to ${agent.label}, then run:\n${MANUAL_STEPS}`);
       return before;
@@ -963,7 +1006,11 @@ async function discoverEndpoints(args, agent, serverName) {
     const after = await endpointCounts(args);
 
     if (!after.registered) {
-      const why = outcome.reason || lastLine(outcome.output) || "it registered nothing";
+      // Both halves: the exit code says the run failed, the agent's own last line
+      // says why, and either one alone has sent someone down the wrong path.
+      const why =
+        [outcome.reason, lastLine(outcome.output)].filter(Boolean).join(" · ") ||
+        "it registered nothing";
       process.stdout.write(
         `${MARK.fail()} ${agent.label} did not register any endpoints (${why}).\n` +
           `   Run it yourself: ${cliInvocation()} endpoints discover\n`
@@ -1069,10 +1116,28 @@ async function setUpRunner(args, agent, { assumeYes }) {
       await registerRunner(args, { agent: agent.id, projectPath: process.cwd() });
     }
     const started = startBackground([]);
+    // Claiming a runner that died two seconds later is worse than saying nothing:
+    // the whole point of this step is that PreMan can act, and someone told it
+    // can will wait for fixes that no device is listening for.
+    const up = await confirmRunnerOnline(started);
+    if (up.state === "exited") {
+      process.stdout.write(
+        `${MARK.fail()} The runner exited right after starting.\n` +
+          (up.detail ? `   ${up.detail}\n` : "") +
+          `   Log: ${started.log}   Retry: ${cliInvocation()} runner start --background\n`
+      );
+      return { state: "failed", detail: up.detail };
+    }
     process.stdout.write(
-      `${MARK.ok()} Runner running (pid ${started.pid}) — PreMan can apply fixes on this machine.\n` +
+      `${MARK.ok()} Runner ${up.state === "online" ? "online" : "starting"} (pid ${started.pid}) — PreMan can apply fixes on this machine.\n` +
         `   Log: ${started.log}   Stop: ${cliInvocation()} runner stop\n`
     );
+    // Paired and online still cannot run anything if the agent it dispatches to
+    // will not start, and every job would fail with the same opaque exit code.
+    const blocker = agentBlocker(agent.id);
+    if (blocker) {
+      process.stdout.write(`   ${MARK.skip()} Jobs will fail until you fix this: ${blocker}\n`);
+    }
     return { state: "running", pid: started.pid };
   } catch (error) {
     process.stdout.write(
@@ -1178,8 +1243,14 @@ async function connectIntegrations(args, apiKey, { assumeYes }) {
   }
 }
 
-/** Install the pre-push hook, so a push is what triggers the tests. */
-async function setUpPushTesting(args, { assumeYes }) {
+/**
+ * Install the pre-push hook, so a push is what triggers the tests.
+ *
+ * Not a question: testing what you just changed before it ships is the product,
+ * the hook cannot block a push, and `--no-hook` / `PREMAN_SKIP_HOOK=1` are both
+ * still there. Asking only produced accounts that never tested anything.
+ */
+async function setUpPushTesting(args) {
   if (args.has("--no-hook")) return { state: "skipped" };
   const current = (() => {
     try {
@@ -1192,14 +1263,12 @@ async function setUpPushTesting(args, { assumeYes }) {
     process.stdout.write(`${MARK.skip()} Not a git repository — no push testing here.\n`);
     return { state: "unavailable" };
   }
-  if (current.state === "installed") {
+  // A hook whose invocation went stale is reinstalled rather than reported as on:
+  // it is the case where PreMan looks connected and silently checks nothing.
+  if (current.state === "installed" && current.current) {
     process.stdout.write(`${MARK.ok()} Push testing already on.\n`);
     return { state: "installed" };
   }
-  if (!(await confirm("Test the endpoints you touched on every git push?", { assumeYes }))) {
-    process.stdout.write(`${MARK.skip()} Skipped. Turn it on: ${cliInvocation()} hook install\n`);
-    return { state: "skipped" };
-  }
 
   const result = installHook(args);
   if (result.action === "conflict") {
@@ -1242,7 +1311,7 @@ async function guidedFirstRun(args, agent, apiKey, serverName) {
   await connectIntegrations(args, apiKey, { assumeYes });
 
   step("Testing on push");
-  await setUpPushTesting(args, { assumeYes });
+  await setUpPushTesting(args);
 
   process.stdout.write(`\nDone. Watch it at ${frontendUrl(args)}\n`);
 }
@@ -1273,6 +1342,16 @@ export async function preflight(args) {
     );
   }
 
+  // Explains why every command below is spelled the long way, before someone
+  // types `preman …` and gets another package's CLI answering.
+  const premanOwner = pathPremanOwner();
+  if (premanOwner && premanOwner !== "premanmcp") {
+    notes.push(
+      `\`preman\` on your PATH belongs to ${premanOwner}, not this CLI, so PreMan's own ` +
+        "commands are written out as `npm exec -y premanmcp@latest -- …`."
+    );
+  }
+
   try {
     const resp = await fetch(new URL("health", `${backendUrl(args)}/`), {
       signal: AbortSignal.timeout(4000),
@@ -1315,7 +1394,8 @@ Connect options:
   --no-desktop                Do not offer the desktop app
   --no-integrations           Do not check or offer GitHub / AWS / Slack
   --no-hook                   Do not install the git pre-push hook
-  --yes                       Accept every optional step without prompting
+  --yes                       Take every step's default without prompting
+                              (the desktop app defaults to no; install-desktop)
   --print                     Print the config instead of writing it
 `;
 
@@ -1482,7 +1562,8 @@ async function establishCheckIn(args, agent, apiKey, { serverName, written, serv
     );
   }
 
-  if (!args.has("--no-auto-checkin")) {
+  const blocker = agentBlocker(agent.id);
+  if (!args.has("--no-auto-checkin") && !blocker) {
     const spec = headlessCheckIn(agent, serverName);
     if (spec && onPath(spec.bin)) {
       process.stdout.write(`\nStarting ${agent.label} to finish the link…\n`);
@@ -1500,6 +1581,11 @@ async function establishCheckIn(args, agent, apiKey, { serverName, written, serv
     } else if (auto.reason) {
       process.stdout.write(`Could not run ${agent.label}: ${auto.reason}\n`);
     }
+  } else if (blocker) {
+    // Starting an agent that cannot authenticate spends two minutes to learn
+    // what one status probe already knows.
+    process.stdout.write(`${MARK.skip()} ${blocker}\n`);
+    notes.push(blocker);
   }
 
   process.stdout.write(

package/bin/hook.js

@@ -56,8 +56,10 @@ if [ -z "\${PREMAN_SKIP_HOOK}" ]; then
   if [ "$preman_status" -eq ${BLOCK_EXIT_CODE} ]; then
     exit ${BLOCK_EXIT_CODE}
   fi
-  if [ "$preman_status" -ne 0 ]; then
-    printf '[preman] checks skipped (%s)\\n' "advisory" >&2
+  if [ "$preman_status" -eq 127 ]; then
+    printf '[preman] the PreMan CLI is not on PATH; push checks skipped\\n' >&2
+  elif [ "$preman_status" -ne 0 ]; then
+    printf '[preman] checks skipped (advisory, exit %s)\\n' "$preman_status" >&2
   fi
 fi
 ${END_MARKER}
@@ -116,11 +118,21 @@ export function uninstallHook() {
   return { path: target, action: "removed" };
 }
 
+/**
+ * `current` is what tells a caller an installed hook still needs rewriting.
+ *
+ * A hook is generated shell holding one invocation, and that invocation can go
+ * stale — the machine gained a `preman` that is not ours, or lost the one that
+ * was. "Installed" then means a file exists that calls the wrong thing on every
+ * push, so anything that skips work when the hook is present has to be able to
+ * tell the difference.
+ */
 export function hookStatus() {
   const target = hookPath();
-  if (!existsSync(target)) return { path: target, state: "absent" };
+  if (!existsSync(target)) return { path: target, state: "absent", current: false };
   const existing = readFileSync(target, "utf8");
-  return { path: target, state: isOurHook(existing) ? "installed" : "foreign" };
+  if (!isOurHook(existing)) return { path: target, state: "foreign", current: false };
+  return { path: target, state: "installed", current: existing === hookBody() };
 }
 
 export async function hookCommand(commandArgs = []) {

package/bin/integrations.js

@@ -17,6 +17,7 @@
 import {
   assertOk,
   callBackendJson,
+  cliInvocation,
   frontendUrl,
   openUrl,
   promptText,
@@ -74,8 +75,10 @@ export class Unrecoverable extends Error {}
  * Returns the truthy value from ``check``, or null on timeout. Ordinary
  * exceptions are swallowed and retried; :class:`Unrecoverable` stops the wait.
  */
-async function waitFor(label, check) {
-  const deadline = Date.now() + POLL_TIMEOUT_MS;
+async function waitFor(label, check, { hint = "", hintAfterMs = 60000 } = {}) {
+  const startedAt = Date.now();
+  const deadline = startedAt + POLL_TIMEOUT_MS;
+  let hinted = false;
   process.stdout.write(`Waiting for ${label}`);
   while (Date.now() < deadline) {
     try {
@@ -91,6 +94,12 @@ async function waitFor(label, check) {
       }
       /* keep waiting; the customer is elsewhere */
     }
+    // A minute of dots is indistinguishable from a hang, and the reason this
+    // waits forever is usually something the customer can act on.
+    if (hint && !hinted && Date.now() - startedAt > hintAfterMs) {
+      hinted = true;
+      process.stdout.write(`\n${hint}\nStill waiting`);
+    }
     process.stdout.write(".");
     await new Promise((resolve) => setTimeout(resolve, POLL_INTERVAL_MS));
   }
@@ -101,7 +110,7 @@ async function waitFor(label, check) {
 function requireKey(args) {
   const apiKey = resolveApiKey(args);
   if (!apiKey) {
-    throw new Error("Not signed in. Run 'preman login' first.");
+    throw new Error(`Not signed in. Run '${cliInvocation()} login' first.`);
   }
   return apiKey;
 }
@@ -156,7 +165,7 @@ export async function awsCommand(args) {
   }
 
   if (!verified) {
-    process.stdout.write("Timed out. Re-run 'preman aws' once the stack finishes.\n");
+    process.stdout.write(`Timed out. Re-run '${cliInvocation()} aws' once the stack finishes.\n`);
     return;
   }
   connected(`AWS connected: ${verified.role_arn}`);
@@ -223,23 +232,35 @@ export async function githubCommand(args) {
   present(url, "install the PreMan GitHub App");
   process.stdout.write("Pick the repositories PreMan may read.\n");
 
-  const done = await waitFor("the installation", async () => {
-    // Installing the App and having repositories appear are two events: the
-    // callback records the installation, and a refresh materialises the repos.
-    // Polling the repo list alone waits for something that may never arrive on
-    // its own.
-    await callBackendJson(args, "POST", "/integrations/github/app/refresh", {
-      token,
-      json: {},
-    });
-    // Compare against what existed before, so a user who already had repos
-    // connected is not told they are done the moment polling starts.
-    const fresh = (await listRepos()).filter((r) => !seen.has(r.id));
-    return fresh.length ? fresh : null;
-  });
+  const done = await waitFor(
+    "the installation",
+    async () => {
+      // Installing the App and having repositories appear are two events: the
+      // callback records the installation, and a refresh materialises the repos.
+      // Polling the repo list alone waits for something that may never arrive on
+      // its own.
+      await callBackendJson(args, "POST", "/integrations/github/app/refresh", {
+        token,
+        json: {},
+      });
+      // Compare against what existed before, so a user who already had repos
+      // connected is not told they are done the moment polling starts.
+      const fresh = (await listRepos()).filter((r) => !seen.has(r.id));
+      return fresh.length ? fresh : null;
+    },
+    {
+      hint:
+        "PreMan has not heard from GitHub yet. Finish the install in the browser tab —\n" +
+        "pick at least one repository and confirm — and GitHub will send you back here.",
+    }
+  );
 
   if (!done) {
-    process.stdout.write("Timed out. Re-run 'preman github' if the install finished.\n");
+    process.stdout.write(
+      `Timed out: GitHub never told PreMan about an installation.\n` +
+        `  - Check that the App is installed: https://github.com/settings/installations\n` +
+        `  - Then re-run '${cliInvocation()} github'.\n`
+    );
     return;
   }
   connected(`GitHub connected: ${done.length} repository(ies).`);
@@ -270,7 +291,7 @@ export async function slackCommand(args) {
   });
 
   if (!done) {
-    process.stdout.write("Timed out. Re-run 'preman slack' if the install finished.\n");
+    process.stdout.write(`Timed out. Re-run '${cliInvocation()} slack' if the install finished.\n`);
     return;
   }
   connected(`Slack connected: ${done[0].team_name || done[0].id}`);

package/bin/runner.js

@@ -24,7 +24,16 @@
 
 import { spawn, spawnSync } from "node:child_process";
 import { createHash } from "node:crypto";
-import { chmodSync, existsSync, mkdirSync, openSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import {
+  chmodSync,
+  existsSync,
+  mkdirSync,
+  openSync,
+  readFileSync,
+  rmSync,
+  statSync,
+  writeFileSync,
+} from "node:fs";
 import os from "node:os";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
@@ -739,9 +748,56 @@ Runner options:
   --full-access                 Let the agent run commands, not just edit files
 `;
 
+function logSize() {
+  try {
+    return statSync(RUNNER_LOG_FILE).size;
+  } catch {
+    return 0;
+  }
+}
+
+/** Whatever the daemon has logged since `offset`, exactly (the log is appended to). */
+export function runnerLogSince(offset = 0) {
+  try {
+    const buffer = readFileSync(RUNNER_LOG_FILE);
+    return buffer.subarray(Math.min(Math.max(0, offset), buffer.length)).toString("utf8");
+  } catch {
+    return "";
+  }
+}
+
+function tailLine(text, cap = 240) {
+  const lines = String(text || "")
+    .split("\n")
+    .map((line) => line.trim())
+    .filter(Boolean);
+  return lines.length ? lines[lines.length - 1].slice(0, cap) : "";
+}
+
+/**
+ * Wait for a just-spawned daemon to prove it is up.
+ *
+ * A pid from `spawn` is not a running runner: registration can be rejected, the
+ * token can be dead, the stream can refuse the connection, and every one of those
+ * exits within a second or two of a "Runner running (pid …)" line nobody had any
+ * reason to doubt. The log offset is taken before the spawn so an earlier
+ * daemon's "connected" line cannot be mistaken for this one's.
+ */
+export async function confirmRunnerOnline({ pid, offset = 0, timeoutMs = 12_000, intervalMs = 250 } = {}) {
+  const deadline = Date.now() + timeoutMs;
+  for (;;) {
+    const fresh = runnerLogSince(offset);
+    if (/connected as runner/.test(fresh)) return { state: "online", detail: "" };
+    if (!runnerIsAlive(pid)) return { state: "exited", detail: tailLine(fresh) };
+    if (Date.now() >= deadline) return { state: "starting", detail: tailLine(fresh) };
+    await sleep(intervalMs);
+  }
+}
+
 /** Start the daemon detached, so a terminal can be closed without killing it. */
 export function startBackground(commandArgs) {
   ensureDir();
+  const offset = logSize();
   // 0600 like everything else under ~/.preman: nothing in here is a credential
   // today, and that is not a property to leave depending on future log lines.
   const log = openSync(RUNNER_LOG_FILE, "a", 0o600);
@@ -753,7 +809,7 @@ export function startBackground(commandArgs) {
   );
   child.unref();
   writeFileSync(RUNNER_PID_FILE, `${child.pid}\n`, { mode: 0o600 });
-  return { pid: child.pid, log: RUNNER_LOG_FILE };
+  return { pid: child.pid, log: RUNNER_LOG_FILE, offset };
 }
 
 async function startForeground(args, commandArgs) {
@@ -827,10 +883,20 @@ export async function runnerCommand(commandArgs = []) {
         return { state: "running", pid: readPid() };
       }
       const started = startBackground(commandArgs.filter((value) => value !== "start"));
+      const up = await confirmRunnerOnline(started);
+      if (up.state === "exited") {
+        rmSync(RUNNER_PID_FILE, { force: true });
+        process.stdout.write(
+          `Runner exited right after starting.\n` +
+            (up.detail ? `  ${up.detail}\n` : "") +
+            `  log: ${started.log}\n`
+        );
+        return { ...started, state: "exited" };
+      }
       process.stdout.write(
-        `Runner started in the background (pid ${started.pid}).\n  log: ${started.log}\n`
+        `Runner ${up.state === "online" ? "online" : "starting"} (pid ${started.pid}).\n  log: ${started.log}\n`
       );
-      return started;
+      return { ...started, state: up.state };
     }
     await startForeground(args, commandArgs);
     return { state: "stopped" };

package/bin/shared.js

@@ -8,7 +8,15 @@
  */
 
 import { spawn, spawnSync } from "node:child_process";
-import { chmodSync, existsSync, readFileSync, rmSync, writeFileSync, mkdirSync } from "node:fs";
+import {
+  chmodSync,
+  existsSync,
+  readFileSync,
+  realpathSync,
+  rmSync,
+  writeFileSync,
+  mkdirSync,
+} from "node:fs";
 import os from "node:os";
 import path from "node:path";
 import { createInterface } from "node:readline/promises";
@@ -29,16 +37,55 @@ export const CREDENTIALS_FILE = path.join(CREDENTIALS_DIR, "credentials.json");
  */
 let _invocation = null;
 
-export function cliInvocation() {
-  if (_invocation) return _invocation;
+/**
+ * The package that owns the first `preman` on PATH, or "".
+ *
+ * `preman` is not ours by name alone: `preman-sdk` publishes a bin called
+ * exactly that, and whichever package lost the race still resolves. Assuming it
+ * is us writes hints and a git hook that call the other CLI — which answers
+ * "Unknown command: verify" and turns every push into a silent
+ * "[preman] checks skipped", the worst possible failure for a tool whose whole
+ * job is running checks on push.
+ */
+export function pathPremanOwner() {
   const probe = process.platform === "win32" ? "where" : "which";
+  let resolved = "";
   try {
     const found = spawnSync(probe, ["preman"], { stdio: "pipe", encoding: "utf8" });
-    _invocation = found.status === 0 && found.stdout.trim() ? "preman" : null;
+    if (found.status !== 0) return "";
+    resolved = String(found.stdout || "").split("\n")[0].trim();
   } catch {
-    _invocation = null;
+    return "";
   }
-  return (_invocation ||= "npm exec -y premanmcp@latest --");
+  if (!resolved) return "";
+
+  // Walk up from the real file, not the symlink: a bin is a link into the
+  // package directory, and only that directory's manifest names the owner.
+  try {
+    let dir = path.dirname(realpathSync(resolved));
+    for (let depth = 0; depth < 5; depth += 1) {
+      const manifest = path.join(dir, "package.json");
+      if (existsSync(manifest)) {
+        return String(JSON.parse(readFileSync(manifest, "utf8")).name || "");
+      }
+      const parent = path.dirname(dir);
+      if (parent === dir) break;
+      dir = parent;
+    }
+  } catch {
+    return "";
+  }
+  return "";
+}
+
+export function cliInvocation() {
+  return (_invocation ||=
+    pathPremanOwner() === "premanmcp" ? "preman" : "npm exec -y premanmcp@latest --");
+}
+
+/** Test seam: `cliInvocation` memoizes a PATH probe for the life of the process. */
+export function resetCliInvocation() {
+  _invocation = null;
 }
 
 export function makeArgs(commandArgs = []) {

package/dist/server.js

@@ -1043,6 +1043,7 @@ export function createServer() {
                             backend_url: BACKEND_URL,
                             frontend_base_url: FRONTEND_BASE,
                             endpoints_page_url: buildAgentDashboardUrl("/endpoints"),
+                            config: configSource(),
                             message: "Not authenticated. Run `npm exec -y premanmcp@latest -- login`, or use user_auth_* then preman_create_api_key, or run preman_login.",
                         }),
                     }],

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "premanmcp",
-  "version": "0.10.0",
+  "version": "0.10.1",
   "description": "Turn APIs into agent-callable MCP tools with auth, testing, and audit logs",
   "type": "module",
   "bin": {
@@ -13,9 +13,9 @@
     "dev": "tsx src/server.ts",
     "open-mcp-preview": "node scripts/emit-mcp-preview.mjs",
     "open-mcp-preview-in-cursor": "node scripts/open-cursor-preview.mjs",
-    "test": "npm run test:connect && npm run test:node",
+    "test": "npm run build && npm run test:connect && npm run test:node",
     "test:connect": "node scripts/smoke-connect.mjs",
-    "test:node": "node --test --test-timeout=30000 scripts/smoke-launcher-config.mjs scripts/smoke-onboard.mjs scripts/smoke-local-detect.mjs scripts/smoke-prepush-hook.mjs scripts/smoke-verify-prepush.mjs scripts/smoke-push-diff.mjs scripts/smoke-progress-reporter.mjs scripts/smoke-verify-plan.mjs scripts/smoke-install-desktop.mjs"
+    "test:node": "node --test --test-timeout=30000 scripts/smoke-launcher-config.mjs scripts/smoke-runner.mjs scripts/smoke-repo-config.mjs scripts/smoke-onboard.mjs scripts/smoke-local-detect.mjs scripts/smoke-prepush-hook.mjs scripts/smoke-cli-identity.mjs scripts/smoke-verify-prepush.mjs scripts/smoke-push-diff.mjs scripts/smoke-progress-reporter.mjs scripts/smoke-verify-plan.mjs scripts/smoke-install-desktop.mjs"
   },
   "dependencies": {
     "@modelcontextprotocol/ext-apps": "^0.1.0",