@proagentstore/cli 0.4.45 → 0.4.47

package/dist/browser-runner/coding/terminal.js

@@ -76,7 +76,14 @@ export function activeTerminalCommand(target, backend) {
         switch (t.backend) {
             case "tmux": {
                 const out = tmuxExec(["display-message", "-p", "-t", t.id, "#{pane_current_command}"]).trim();
-                return out || null;
+                // `#{pane_current_command}` reads the pane process's argv, and Claude Code rewrites
+                // its own — measured on this platform's flagship case, tmux answered `2.1.226` (the
+                // version) for a pane whose process `comm` was `claude`. So `aiCliDrives` was 0 for a
+                // week of driving Claude Code through a tmux Operator. `comm` is the executable name
+                // and no title rewrite touches it, so ask the process tree when the argv is not a
+                // name (#498). Only then: a pane reporting `zsh` genuinely has nothing in the
+                // foreground, and promoting a background child would be an invention.
+                return resolvePaneCommand(out, () => paneDescendantComms(t.id));
             }
             case "kitty":
                 return kittyForegroundCommand(t.id);
@@ -90,6 +97,102 @@ export function activeTerminalCommand(target, backend) {
         return null;
     }
 }
+/** Shell names that mean "the pane is at a prompt", not "this program is running". */
+const SHELL_NAMES = new Set(["sh", "bash", "zsh", "fish", "dash", "ksh", "tcsh", "csh", "login", "screen", "tmux"]);
+/** A program name is a bare token. A version (`2.1.226`) and a sentence are both NOT one. */
+export function looksLikeCommandName(raw) {
+    const value = String(raw ?? "").trim();
+    if (!value || value.length > 60)
+        return false;
+    if (/^v?\d+(\.\d+)+$/.test(value))
+        return false; // a version string is not a program name
+    return /^[A-Za-z_][\w.@+-]*$/.test(value);
+}
+/**
+ * What the pane is running, given what tmux SAID and a way to ask the process tree (#498).
+ *
+ * Pure so the measured fixture — tmux says `2.1.226`, the pane's child `comm` is `claude` — is a
+ * unit test rather than a story. Keeps tmux's answer whenever it is a name: that is the fast path,
+ * it costs no extra exec, and the descendant walk can only ever be a second-best guess.
+ */
+export function resolvePaneCommand(reported, listDescendantComms) {
+    const value = String(reported ?? "").trim();
+    if (looksLikeCommandName(value))
+        return value;
+    // The probe is best-effort by construction: `pgrep`/`ps` availability differs by platform, and
+    // a missing one must degrade to what tmux said, not lose it.
+    let descendants = [];
+    try {
+        descendants = listDescendantComms();
+    }
+    catch {
+        descendants = [];
+    }
+    for (const raw of descendants) {
+        const name = (String(raw ?? "").trim().split("/").pop() ?? "").trim();
+        if (!looksLikeCommandName(name))
+            continue;
+        if (SHELL_NAMES.has(name.toLowerCase()))
+            continue;
+        return name;
+    }
+    // Nothing better found: hand back exactly what tmux said. The cloud decides what an
+    // unreadable value means; this module does not invent a name it did not read.
+    return value || null;
+}
+/** Bounded, so a probe on a path a Loop drives continuously can never become the slow part. */
+const PROBE_TIMEOUT_MS = 1_000;
+/** `comm` for the pane's descendant processes, nearest first. `[]` on any failure. */
+function paneDescendantComms(paneId) {
+    let pid = "";
+    try {
+        pid = tmuxExec(["display-message", "-p", "-t", paneId, "#{pane_pid}"], PROBE_TIMEOUT_MS).trim();
+    }
+    catch {
+        return [];
+    }
+    if (!/^\d+$/.test(pid))
+        return [];
+    const found = [];
+    let frontier = [pid];
+    // Two levels is enough for `zsh → claude` and for one wrapper in between, and it bounds the
+    // work: `pgrep`/`ps` availability differs by platform, so every step degrades to today's
+    // answer rather than throwing (the runner is macOS/Linux; kitty and iTerm2 are untouched).
+    for (let depth = 0; depth < 2 && frontier.length > 0; depth++) {
+        const children = childPids(frontier);
+        if (children.length === 0)
+            break;
+        found.push(...commsFor(children));
+        frontier = children;
+    }
+    return found;
+}
+function childPids(parents) {
+    try {
+        const out = execFileSync("pgrep", ["-P", parents.join(",")], {
+            encoding: "utf8",
+            timeout: PROBE_TIMEOUT_MS,
+            stdio: ["ignore", "pipe", "ignore"],
+        });
+        return out.split("\n").map((s) => s.trim()).filter((s) => /^\d+$/.test(s)).slice(0, 16);
+    }
+    catch {
+        return []; // pgrep exits non-zero when nothing matches — that is an answer, not an error
+    }
+}
+function commsFor(pids) {
+    try {
+        const out = execFileSync("ps", ["-o", "comm=", "-p", pids.join(",")], {
+            encoding: "utf8",
+            timeout: PROBE_TIMEOUT_MS,
+            stdio: ["ignore", "pipe", "ignore"],
+        });
+        return out.split("\n").map((s) => s.trim()).filter(Boolean);
+    }
+    catch {
+        return [];
+    }
+}
 /** The foreground process of a kitty window, from `kitty @ ls`. Null if it can't be determined. */
 function kittyForegroundCommand(id) {
     try {

package/dist/browser-runner/coding/tmux.js

@@ -111,6 +111,47 @@ export function runCommand(target, command) {
     sendText(target, command);
     sendKey(target, "Enter");
 }
+/**
+ * Settle heuristic constants — mirror the Coder headless.ts values (1.5s quiet = idle;
+ * 8s absolute backstop for a slow-booting CLI). The short backstop covers send/run where
+ * the pane is already live; the long one is for new-session launches where the CLI may
+ * take several seconds to paint its first prompt.
+ */
+export const SETTLE_QUIET_MS = 750;
+export const SETTLE_POLL_MS = 120;
+export const SETTLE_TIMEOUT_MS = 8_000;
+/**
+ * Poll-capture a pane until its content is unchanged for `quietMs` ms, or until
+ * `timeoutMs` elapses (backstop so a continuously-animated pane can't hang the tool).
+ *
+ * Returns the final pane content. This is the write-side analogue of the read-side labels
+ * in `terminal-label.ts`: before returning "Sent", we verify the pane has reacted.
+ *
+ * Pure behaviour — no side effects beyond calling `capturePane`; tested in unit tests
+ * without a real tmux by passing a custom `captureFn`.
+ */
+export async function waitForPaneSettle(target, opts = {}) {
+    const quietMs = opts.quietMs ?? SETTLE_QUIET_MS;
+    const timeoutMs = opts.timeoutMs ?? SETTLE_TIMEOUT_MS;
+    const pollMs = opts.pollMs ?? SETTLE_POLL_MS;
+    const capture = opts.captureFn ?? ((t) => capturePane(t));
+    const deadline = Date.now() + timeoutMs;
+    let last = capture(target);
+    let lastChangedAt = Date.now();
+    while (true) {
+        await new Promise((r) => setTimeout(r, pollMs));
+        const now = Date.now();
+        const current = capture(target);
+        if (current !== last) {
+            last = current;
+            lastChangedAt = now;
+        }
+        const quietFor = now - lastChangedAt;
+        if (quietFor >= quietMs || now >= deadline) {
+            return last;
+        }
+    }
+}
 // biome-ignore lint/suspicious/noControlCharactersInRegex: matching ANSI escape codes from tmux output.
 const ANSI = /\x1B\[[0-?]*[ -/]*[@-~]/g;
 /** Strip ANSI escape codes. */

package/dist/browser-runner/server.js

@@ -305,24 +305,29 @@ async function route(runner, req, res) {
         return json(res, 200, { session, pane: capturePane(session, lines) });
     }
     if (req.method === "POST" && path === "/tmux/send") {
-        const { sendText, sendKey, capturePane, sessionExists } = await import("./coding/tmux.js");
+        const { sendText, sendKey, capturePane, sessionExists, waitForPaneSettle } = await import("./coding/tmux.js");
         const b = await readJson(req);
         const session = String(b.session || "").trim();
         if (!session)
             return json(res, 400, { error: "A `session` name is required." });
         if (!sessionExists(session))
             return json(res, 404, { error: `No tmux session "${session}".` });
+        // Capture BEFORE the send so the caller can verify what changed (#481).
+        const paneBefore = capturePane(session, 200);
         if (b.text != null)
             sendText(session, String(b.text));
         for (const k of b.keys ?? [])
             sendKey(session, String(k));
+        // Wait for the pane to quiesce (750ms quiet / 3s backstop) instead of returning
+        // the pre-reaction snapshot. Mirrors the settle heuristic in headless.ts.
+        const pane = await waitForPaneSettle(session, { quietMs: 750, timeoutMs: 3_000 });
         // `activeCommand` rides along on every WRITE so the cloud can record what it just drove
         // (#348). It is a process name, never a cost — see activeTerminalCommand's comment.
         const { activeTerminalCommand } = await import("./coding/terminal.js");
-        return json(res, 200, { session, pane: capturePane(session, 200), activeCommand: activeTerminalCommand(session, "tmux") });
+        return json(res, 200, { session, pane, paneBefore, changed: pane !== paneBefore, activeCommand: activeTerminalCommand(session, "tmux") });
     }
     if (req.method === "POST" && path === "/tmux/run") {
-        const { runCommand, capturePane, sessionExists } = await import("./coding/tmux.js");
+        const { runCommand, capturePane, sessionExists, waitForPaneSettle } = await import("./coding/tmux.js");
         const b = await readJson(req);
         const session = String(b.session || "").trim();
         const command = String(b.command ?? "");
@@ -332,12 +337,14 @@ async function route(runner, req, res) {
             return json(res, 400, { error: "A `command` is required." });
         if (!sessionExists(session))
             return json(res, 404, { error: `No tmux session "${session}".` });
+        const paneBefore = capturePane(session, 200);
         runCommand(session, command);
+        const pane = await waitForPaneSettle(session, { quietMs: 750, timeoutMs: 3_000 });
         const { activeTerminalCommand } = await import("./coding/terminal.js");
-        return json(res, 200, { session, command, pane: capturePane(session, 200), activeCommand: activeTerminalCommand(session, "tmux") });
+        return json(res, 200, { session, command, pane, paneBefore, changed: pane !== paneBefore, activeCommand: activeTerminalCommand(session, "tmux") });
     }
     if (req.method === "POST" && path === "/tmux/session") {
-        const { createSession, killSession, sessionExists } = await import("./coding/tmux.js");
+        const { createSession, killSession, sessionExists, waitForPaneSettle } = await import("./coding/tmux.js");
         const { homedir } = await import("node:os");
         const b = await readJson(req);
         const session = String(b.session || "").trim();
@@ -352,6 +359,12 @@ async function route(runner, req, res) {
         const { resolve } = await import("node:path");
         const workDir = resolve(String(b.workDir || "~").replace(/^~(?=$|\/)/, homedir()));
         createSession(session, workDir, b.command ? String(b.command) : undefined);
+        // When the session starts a command (e.g. "claude"), wait until the pane quiesces
+        // (the CLI has painted its initial prompt) before returning "ready" (#481). Without a
+        // startup command the pane is already at a shell prompt — no settle needed.
+        if (b.command) {
+            await waitForPaneSettle(session, { quietMs: 750, timeoutMs: 8_000 });
+        }
         return json(res, 200, { session, created: true, workDir });
     }
     // ── generic terminal connector ──────────────────────────────────────────
@@ -373,7 +386,8 @@ async function route(runner, req, res) {
         return json(res, 200, { target, pane: captureTerminalTarget(target, { backend, lines: b.lines }) });
     }
     if (req.method === "POST" && path === "/terminal/run") {
-        const { runTerminalCommand, activeTerminalCommand } = await import("./coding/terminal.js");
+        const { runTerminalCommand, captureTerminalTarget, activeTerminalCommand } = await import("./coding/terminal.js");
+        const { waitForPaneSettle, SETTLE_QUIET_MS } = await import("./coding/tmux.js");
         const b = await readJson(req);
         const target = String(b.target || "").trim();
         const command = String(b.command ?? "");
@@ -382,23 +396,48 @@ async function route(runner, req, res) {
         if (!command.trim())
             return json(res, 400, { error: "A `command` is required." });
         const backend = b.backend === "tmux" || b.backend === "kitty" || b.backend === "iterm2" ? b.backend : undefined;
-        const pane = runTerminalCommand(target, command, backend);
+        // Capture BEFORE to detect whether the input landed (#481).
+        const paneBefore = captureTerminalTarget(target, { backend });
+        runTerminalCommand(target, command, backend);
+        // Settle: for tmux targets, use the tmux poll. For other backends, fall back to the
+        // just-run snapshot (they don't support a reliable settle poll).
+        let pane;
+        if (!backend && target.startsWith("tmux:") || backend === "tmux") {
+            const { splitTerminalTarget } = await import("./coding/terminal.js");
+            const t = splitTerminalTarget(target, backend);
+            pane = await waitForPaneSettle(t.id, { quietMs: SETTLE_QUIET_MS, timeoutMs: 3_000 });
+        }
+        else {
+            pane = captureTerminalTarget(target, { backend });
+        }
         // Read AFTER the command lands, so `claude "fix x"` reports `claude` rather than the shell
         // that was sitting there a moment earlier (#348).
-        return json(res, 200, { target, command, pane, activeCommand: activeTerminalCommand(target, backend) });
+        return json(res, 200, { target, command, pane, paneBefore, changed: pane !== paneBefore, activeCommand: activeTerminalCommand(target, backend) });
     }
     if (req.method === "POST" && path === "/terminal/send") {
-        const { sendTerminalKeys, activeTerminalCommand } = await import("./coding/terminal.js");
+        const { sendTerminalKeys, captureTerminalTarget, activeTerminalCommand } = await import("./coding/terminal.js");
+        const { waitForPaneSettle, SETTLE_QUIET_MS } = await import("./coding/tmux.js");
         const b = await readJson(req);
         const target = String(b.target || "").trim();
         if (!target)
             return json(res, 400, { error: "A `target` is required." });
         const backend = b.backend === "tmux" || b.backend === "kitty" || b.backend === "iterm2" ? b.backend : undefined;
-        const pane = sendTerminalKeys(target, { backend, text: b.text == null ? undefined : String(b.text), keys: b.keys ?? [] });
-        return json(res, 200, { target, pane, activeCommand: activeTerminalCommand(target, backend) });
+        const paneBefore = captureTerminalTarget(target, { backend });
+        sendTerminalKeys(target, { backend, text: b.text == null ? undefined : String(b.text), keys: b.keys ?? [] });
+        let pane;
+        if (!backend && target.startsWith("tmux:") || backend === "tmux") {
+            const { splitTerminalTarget } = await import("./coding/terminal.js");
+            const t = splitTerminalTarget(target, backend);
+            pane = await waitForPaneSettle(t.id, { quietMs: SETTLE_QUIET_MS, timeoutMs: 3_000 });
+        }
+        else {
+            pane = captureTerminalTarget(target, { backend });
+        }
+        return json(res, 200, { target, pane, paneBefore, changed: pane !== paneBefore, activeCommand: activeTerminalCommand(target, backend) });
     }
     if (req.method === "POST" && path === "/terminal/session") {
         const { createTerminalTarget, killTerminalTarget } = await import("./coding/terminal.js");
+        const { waitForPaneSettle } = await import("./coding/tmux.js");
         const b = await readJson(req);
         const backend = b.backend === "tmux" || b.backend === "kitty" || b.backend === "iterm2" ? b.backend : undefined;
         if (b.action === "kill") {
@@ -410,6 +449,10 @@ async function route(runner, req, res) {
         if (!backend)
             return json(res, 400, { error: "`backend` must be tmux, kitty, or iterm2." });
         const target = createTerminalTarget({ backend, name: b.name, workDir: b.workDir, command: b.command });
+        // When the new target starts a command, wait until the pane quiesces (#481).
+        if (b.command && backend === "tmux" && !target.existed) {
+            await waitForPaneSettle(target.id, { quietMs: 750, timeoutMs: 8_000 });
+        }
         return json(res, 200, { target });
     }
     return json(res, 404, { error: "Not found" });

package/dist/index.js

@@ -549,6 +549,14 @@ function withClaimedNames(identity, claimed) {
     declined: (identity.declined ?? []).filter((n) => !add.includes(n))
   };
 }
+function withUnclaimedName(identity, name) {
+  const unclaim = name.trim();
+  if (!unclaim) return identity;
+  const names = identity.names.filter((n) => n !== unclaim);
+  const declined = [...identity.declined ?? []];
+  if (!declined.includes(unclaim)) declined.push(unclaim);
+  return { id: identity.id, names, declined: declined.slice(-MAX_DECLINED) };
+}
 function withDeclinedNames(identity, declined) {
   const out = [...identity.declined ?? []];
   for (const raw of declined) {
@@ -699,7 +707,7 @@ function renderCandidates(candidates, nowMs) {
   });
   lines.push("");
   lines.push("Selecting a name merges its agents, pins and sessions onto this machine.");
-  lines.push("Pick only names THIS machine has used \u2014 a claim cannot be undone from the CLI.");
+  lines.push("Pick only names THIS machine has used \u2014 use `pags machines unclaim <name>` to undo a wrong claim.");
   return lines;
 }
 async function fetchNodeSummaries(opts) {
@@ -777,6 +785,96 @@ async function defaultAsk(question) {
   }
 }
 
+// src/commands/runner/http.ts
+import { hostname as hostname2 } from "os";
+function clean(value) {
+  const trimmed = value?.trim();
+  return trimmed || void 0;
+}
+function runnerBaseUrl(url) {
+  return (clean(url) || clean(process.env.PAGS_RUNNER_URL) || "http://127.0.0.1:49171").replace(/\/$/, "");
+}
+function pagsApiBase(url) {
+  return (clean(url) || clean(process.env.PAGS_API_BASE) || "https://api.proagentstore.online").replace(/\/$/, "");
+}
+function pagsHeaders(token) {
+  const resolved = clean(token) || clean(process.env.PAGS_TOKEN) || clean(loadSession()?.token);
+  return resolved ? { Authorization: `Bearer ${resolved}` } : {};
+}
+function runnerRequestHeaders(opts) {
+  const resolved = clean(opts.token) || clean(process.env.PAGS_RUNNER_TOKEN);
+  const headers = resolved ? { Authorization: `Bearer ${resolved}` } : {};
+  const instanceId = clean(opts.instanceId) || clean(process.env.PAGS_INSTANCE_ID);
+  if (instanceId) headers["X-PAGS-Instance-Id"] = instanceId;
+  return headers;
+}
+function apiPathSegment(value) {
+  return encodeURIComponent(value);
+}
+function buildRuntimeRegistrationBody(opts, capabilities = []) {
+  const node = hostname2();
+  const machine = loadMachineIdentity(node);
+  return {
+    endpointUrl: clean(opts.endpointUrl) || opts.endpointUrl,
+    token: clean(opts.runnerToken) || clean(opts.token) || clean(process.env.PAGS_RUNNER_TOKEN),
+    placement: opts.placement === "managed" ? "managed" : "local",
+    capabilities,
+    runnerVersion: clean(opts.runnerVersion) || "",
+    runnerNode: node,
+    machineId: machine.id,
+    machineNames: machine.names
+  };
+}
+async function requestRunner(method, path, opts, body) {
+  const headers = {
+    ...runnerRequestHeaders(opts)
+  };
+  if (body !== void 0) headers["Content-Type"] = "application/json";
+  const res = await fetch(`${runnerBaseUrl(opts.url)}${path}`, {
+    method,
+    headers,
+    body: body === void 0 ? void 0 : JSON.stringify(body)
+  });
+  const { text, data } = await readResponse(res);
+  if (!res.ok) {
+    const message = responseErrorMessage(data, text, res.statusText);
+    throw new Error(`${res.status} ${message}`);
+  }
+  return data;
+}
+async function requestPags(method, path, opts, body) {
+  const headers = {
+    ...pagsHeaders(opts.pagsToken)
+  };
+  if (!headers.Authorization) {
+    throw new Error("PAGS token required. Set PAGS_TOKEN or pass --pags-token.");
+  }
+  if (body !== void 0) headers["Content-Type"] = "application/json";
+  const res = await fetch(`${pagsApiBase(opts.apiBase)}${path}`, {
+    method,
+    headers,
+    body: body === void 0 ? void 0 : JSON.stringify(body)
+  });
+  const { text, data } = await readResponse(res);
+  if (!res.ok) {
+    const message = responseErrorMessage(data, text, res.statusText);
+    throw new Error(`${res.status} ${message}`);
+  }
+  return data;
+}
+async function readResponse(res) {
+  const text = await res.text();
+  if (!text) return { text, data: {} };
+  try {
+    return { text, data: JSON.parse(text) };
+  } catch {
+    return { text, data: {} };
+  }
+}
+function responseErrorMessage(data, text, statusText) {
+  return typeof data.error === "string" ? data.error : text || statusText;
+}
+
 // src/commands/machines.ts
 var API_BASE2 = "https://api.proagentstore.online";
 async function loadNodes(token) {
@@ -804,6 +902,7 @@ var listCommand = new Command4("list").description("List the machines ProAgentSt
   }
   writeLine("");
   writeLine("  Claim a name this machine has used before:  pags machines claim <name>");
+  writeLine("  Remove a wrong claim:                       pags machines unclaim <name>");
   writeLine("");
 });
 var claimCommand = new Command4("claim").description("Record that a machine name on this account is THIS machine").argument("<name...>", "Node name(s) to claim, as shown by `pags machines list`").action(async (names) => {
@@ -826,7 +925,51 @@ var claimCommand = new Command4("claim").description("Record that a machine name
   }
   writeLine(`  \u2713 Claimed ${claim.join(", ")}. Restart \`pags up\` to merge them onto this machine.`);
 });
-var machinesCommand = new Command4("machines").description("Show and claim the machine names ProAgentStore has for this account").addCommand(listCommand, { isDefault: true }).addCommand(claimCommand);
+var unclaimCommand = new Command4("unclaim").description("Remove a mistaken machine name claim from this machine (#467)").argument("<name...>", "Node name(s) to un-claim, as shown by `pags machines list`").action(async (names) => {
+  const session = requireSession();
+  const identity = loadMachineIdentity();
+  if (!identity.id) {
+    writeError("This machine has no id \u2014 `~/.config/proagentstore/` is not writable, so the claim record cannot be found.");
+    process.exit(1);
+  }
+  let anyFailed = false;
+  for (const raw of names) {
+    const name = raw.trim();
+    if (!name) continue;
+    if (name === identity.names[0]) {
+      writeError(`  \u2717 ${name}: this is the machine's CURRENT hostname. You cannot un-claim the name it is actively registering under \u2014 stop \`pags up\` and rename the machine first.`);
+      anyFailed = true;
+      continue;
+    }
+    if (!identity.names.includes(name)) {
+      writeError(`  \u2717 ${name}: this machine does not claim that name.`);
+      anyFailed = true;
+      continue;
+    }
+    try {
+      await requestPags(
+        "DELETE",
+        `/v1/terminals/nodes/${apiPathSegment(name)}/claim`,
+        { pagsToken: session.token, apiBase: pagsApiBase() },
+        { machineId: identity.id }
+      );
+    } catch (e) {
+      const msg = e instanceof Error ? e.message : String(e);
+      writeError(`  \u2717 ${name}: ${msg}`);
+      anyFailed = true;
+      continue;
+    }
+    const updated = withUnclaimedName(identity, name);
+    if (!saveMachineIdentity(updated)) {
+      writeError(`  \u2717 Server un-claimed ${name} but could not update ${machineFilePath()} \u2014 the next \`pags up\` may re-stamp it. Edit that file by hand and remove "${name}" from the names array.`);
+      anyFailed = true;
+      continue;
+    }
+    writeLine(`  \u2713 ${name} \u2014 un-claimed on server and removed from ${machineFilePath()}.`);
+  }
+  if (anyFailed) process.exit(1);
+});
+var machinesCommand = new Command4("machines").description("Show and claim the machine names ProAgentStore has for this account").addCommand(listCommand, { isDefault: true }).addCommand(claimCommand).addCommand(unclaimCommand);
 
 // src/commands/mcp.ts
 import { spawn } from "child_process";
@@ -951,96 +1094,6 @@ import { spawn as spawn3 } from "child_process";
 import { randomUUID as randomUUID2 } from "crypto";
 import { Command as Command7 } from "commander";
 
-// src/commands/runner/http.ts
-import { hostname as hostname2 } from "os";
-function clean(value) {
-  const trimmed = value?.trim();
-  return trimmed || void 0;
-}
-function runnerBaseUrl(url) {
-  return (clean(url) || clean(process.env.PAGS_RUNNER_URL) || "http://127.0.0.1:49171").replace(/\/$/, "");
-}
-function pagsApiBase(url) {
-  return (clean(url) || clean(process.env.PAGS_API_BASE) || "https://api.proagentstore.online").replace(/\/$/, "");
-}
-function pagsHeaders(token) {
-  const resolved = clean(token) || clean(process.env.PAGS_TOKEN) || clean(loadSession()?.token);
-  return resolved ? { Authorization: `Bearer ${resolved}` } : {};
-}
-function runnerRequestHeaders(opts) {
-  const resolved = clean(opts.token) || clean(process.env.PAGS_RUNNER_TOKEN);
-  const headers = resolved ? { Authorization: `Bearer ${resolved}` } : {};
-  const instanceId = clean(opts.instanceId) || clean(process.env.PAGS_INSTANCE_ID);
-  if (instanceId) headers["X-PAGS-Instance-Id"] = instanceId;
-  return headers;
-}
-function apiPathSegment(value) {
-  return encodeURIComponent(value);
-}
-function buildRuntimeRegistrationBody(opts, capabilities = []) {
-  const node = hostname2();
-  const machine = loadMachineIdentity(node);
-  return {
-    endpointUrl: clean(opts.endpointUrl) || opts.endpointUrl,
-    token: clean(opts.runnerToken) || clean(opts.token) || clean(process.env.PAGS_RUNNER_TOKEN),
-    placement: opts.placement === "managed" ? "managed" : "local",
-    capabilities,
-    runnerVersion: clean(opts.runnerVersion) || "",
-    runnerNode: node,
-    machineId: machine.id,
-    machineNames: machine.names
-  };
-}
-async function requestRunner(method, path, opts, body) {
-  const headers = {
-    ...runnerRequestHeaders(opts)
-  };
-  if (body !== void 0) headers["Content-Type"] = "application/json";
-  const res = await fetch(`${runnerBaseUrl(opts.url)}${path}`, {
-    method,
-    headers,
-    body: body === void 0 ? void 0 : JSON.stringify(body)
-  });
-  const { text, data } = await readResponse(res);
-  if (!res.ok) {
-    const message = responseErrorMessage(data, text, res.statusText);
-    throw new Error(`${res.status} ${message}`);
-  }
-  return data;
-}
-async function requestPags(method, path, opts, body) {
-  const headers = {
-    ...pagsHeaders(opts.pagsToken)
-  };
-  if (!headers.Authorization) {
-    throw new Error("PAGS token required. Set PAGS_TOKEN or pass --pags-token.");
-  }
-  if (body !== void 0) headers["Content-Type"] = "application/json";
-  const res = await fetch(`${pagsApiBase(opts.apiBase)}${path}`, {
-    method,
-    headers,
-    body: body === void 0 ? void 0 : JSON.stringify(body)
-  });
-  const { text, data } = await readResponse(res);
-  if (!res.ok) {
-    const message = responseErrorMessage(data, text, res.statusText);
-    throw new Error(`${res.status} ${message}`);
-  }
-  return data;
-}
-async function readResponse(res) {
-  const text = await res.text();
-  if (!text) return { text, data: {} };
-  try {
-    return { text, data: JSON.parse(text) };
-  } catch {
-    return { text, data: {} };
-  }
-}
-function responseErrorMessage(data, text, statusText) {
-  return typeof data.error === "string" ? data.error : text || statusText;
-}
-
 // src/commands/runner/process.ts
 import { spawn as spawn2 } from "child_process";
 import { existsSync as existsSync6 } from "fs";
@@ -1161,11 +1214,44 @@ function diffMembership(attached, eligible, thisNode, blocked = /* @__PURE__ */
     detach: [...have].filter((id) => !wantIds.has(id))
   };
 }
+function shouldRegisterOnOpen(reconnect, alreadyRegistered) {
+  return reconnect || !alreadyRegistered;
+}
 function instanceLabel(inst) {
   const short = `${inst.id.slice(0, 8)}\u2026`;
   return inst.name ? `${inst.name} (${short})` : short;
 }
 
+// src/commands/runner/status-line.ts
+var STATUS_PREFIX = "PAGS-STATUS";
+function formatStatusLine(status) {
+  const parts = [];
+  if (status.registration) parts.push(`registration=${status.registration}`);
+  if (status.heartbeat) parts.push(`heartbeat=${status.heartbeat}`);
+  if (status.agents) parts.push(`agents=${status.agents}`);
+  if (status.reason) parts.push(`reason=${status.reason.replace(/\s+/g, " ").trim().slice(0, 200)}`);
+  return `${STATUS_PREFIX} ${parts.join(" ")}`;
+}
+function parseStatusLine(line) {
+  const trimmed = line.trim();
+  if (!trimmed.startsWith(`${STATUS_PREFIX} `)) return null;
+  const body = trimmed.slice(STATUS_PREFIX.length + 1);
+  const status = {};
+  const reasonAt = body.indexOf("reason=");
+  const head = reasonAt >= 0 ? body.slice(0, reasonAt) : body;
+  if (reasonAt >= 0) {
+    const reason = body.slice(reasonAt + "reason=".length).trim();
+    if (reason) status.reason = reason;
+  }
+  for (const token of head.split(/\s+/).filter(Boolean)) {
+    const [key, value] = token.split("=", 2);
+    if (key === "registration" && (value === "ok" || value === "partial" || value === "fail")) status.registration = value;
+    else if (key === "heartbeat" && (value === "ok" || value === "fail")) status.heartbeat = value;
+    else if (key === "agents" && value) status.agents = value;
+  }
+  return status;
+}
+
 // src/commands/runner/relay.ts
 async function connectViaRelay(instanceIds, localUrl, runnerToken, opts, force = false, watchInstances = false) {
   const apiBase = pagsApiBase(opts.apiBase).replace(/^http/, "ws");
@@ -1175,7 +1261,9 @@ async function connectViaRelay(instanceIds, localUrl, runnerToken, opts, force =
   const machine = loadMachineIdentity(runnerNode);
   const capabilities = await requestRunner("GET", "/capabilities", { url: localUrl, token: runnerToken, instanceId: instanceIds[0] });
   const caps = Array.isArray(capabilities.capabilities) ? capabilities.capabilities.filter((item) => typeof item === "string") : [];
-  const registerRuntime = async (id) => {
+  const registered = /* @__PURE__ */ new Set();
+  let lastRegisterError = "";
+  const registerRuntime = async (id, forceClaim = force) => {
     try {
       await requestPags("POST", `/v1/instances/${apiPathSegment(id)}/runtime`, opts, {
         endpointUrl: localUrl,
@@ -1186,13 +1274,23 @@ async function connectViaRelay(instanceIds, localUrl, runnerToken, opts, force =
         runnerNode,
         machineId: machine.id,
         machineNames: machine.names,
-        force
+        force: forceClaim
       });
+      registered.add(id);
+      return true;
     } catch (e) {
       const msg = e instanceof Error ? e.message : String(e);
+      registered.delete(id);
+      lastRegisterError = msg;
       writeError(`register ${id.slice(0, 8)}\u2026 failed: ${msg}`);
+      return false;
     }
   };
+  const reportRegistration = () => {
+    const agents = `${registered.size}/${instanceIds.length}`;
+    const state = registered.size === instanceIds.length ? "ok" : registered.size === 0 ? "fail" : "partial";
+    writeLine(formatStatusLine({ registration: state, agents, reason: state === "ok" ? void 0 : lastRegisterError }));
+  };
   for (const id of instanceIds) await registerRuntime(id);
   const attached = /* @__PURE__ */ new Map();
   const blocked = /* @__PURE__ */ new Set();
@@ -1201,10 +1299,31 @@ async function connectViaRelay(instanceIds, localUrl, runnerToken, opts, force =
     const mintToken = () => requestPags("POST", `/v1/relay/${apiPathSegment(id)}/token`, { ...opts, pagsToken }, {}).then((r) => r.token);
     attached.set(
       id,
-      openRelaySocket(id, apiBase, mintToken, localUrl, runnerToken, force, (conflicted) => {
-        blocked.add(conflicted);
-        attached.delete(conflicted);
-      })
+      openRelaySocket(
+        id,
+        apiBase,
+        mintToken,
+        localUrl,
+        runnerToken,
+        force,
+        (conflicted) => {
+          blocked.add(conflicted);
+          attached.delete(conflicted);
+        },
+        // Registration rides the RECONNECT, which is the whole wake case (#497). The socket
+        // retries with backoff; `POST …/runtime` did not, so after a sleep the machine had a
+        // live relay and no runtime row — and `resumeSessionsForNode`, which lives inside that
+        // route, never ran either, so its own suspended coding sessions stayed suspended. The
+        // upsert is idempotent, so re-registering on every reconnect is safe. The first open
+        // is skipped when the register already succeeded above (or in the discovery pass),
+        // and taken when it did not — which is how a register lost to a boot-time
+        // `fetch failed` finally gets a second chance.
+        async (openedId, reconnect) => {
+          if (!shouldRegisterOnOpen(reconnect, registered.has(openedId))) return;
+          await registerRuntime(openedId, reconnect ? false : force);
+          reportRegistration();
+        }
+      )
     );
     if (label) writeLine(`Attached agent: ${label}`);
   };
@@ -1216,7 +1335,8 @@ async function connectViaRelay(instanceIds, localUrl, runnerToken, opts, force =
     writeLine(`Detached agent: ${label}`);
   };
   for (const id of instanceIds) attach(id, "");
-  writeLine("Runtime registered with PAGS \u2713");
+  reportRegistration();
+  writeLine(registered.size === instanceIds.length ? `Runtime registered with PAGS \u2713 (${registered.size}/${instanceIds.length} agents)` : `Runtime registration incomplete: ${registered.size}/${instanceIds.length} agents \u2014 retried on each relay (re)connect.`);
   writeLine("");
   writeLine("\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550");
   writeLine(`  \u2705 CONNECTED \u2014 WebSocket relay \xB7 ${hostname3()}`);
@@ -1236,9 +1356,11 @@ async function connectViaRelay(instanceIds, localUrl, runnerToken, opts, force =
       }
       if (failure && !heartbeatFailing) {
         heartbeatFailing = true;
+        writeLine(formatStatusLine({ heartbeat: "fail", reason: failure }));
         writeError(`Heartbeat failed: ${failure} \u2014 the console will show this machine as OFFLINE until it recovers. The relay itself is still connected; don't run \`pags up --force\` elsewhere.`);
       } else if (!failure && heartbeatFailing) {
         heartbeatFailing = false;
+        writeLine(formatStatusLine({ heartbeat: "ok" }));
         writeLine("Heartbeat recovered \u2014 this machine reads as online again.");
       }
       heartbeat();
@@ -1247,10 +1369,23 @@ async function connectViaRelay(instanceIds, localUrl, runnerToken, opts, force =
   };
   heartbeat();
   if (watchInstances) startDiscovery();
+  async function clearFinishedConflicts() {
+    for (const id of [...blocked]) {
+      const free = await requestPags(
+        "GET",
+        `/v1/relay/${apiPathSegment(id)}/status`,
+        { ...opts, pagsToken }
+      ).then((r) => r.connected === false).catch(() => false);
+      if (!free) continue;
+      blocked.delete(id);
+      writeLine(`Relay conflict cleared: ${id.slice(0, 8)}\u2026 \u2014 the other runner is gone; reattaching.`);
+    }
+  }
   function startDiscovery() {
     const tick = () => {
       const timer = setTimeout(async () => {
         try {
+          await clearFinishedConflicts();
           const res = await requestPags(
             "GET",
             "/v1/instances/my/instances",
@@ -1280,10 +1415,11 @@ async function connectViaRelay(instanceIds, localUrl, runnerToken, opts, force =
     tick();
   }
 }
-function openRelaySocket(instanceId, wsBase, mintToken, localUrl, runnerToken, force = false, onConflict) {
+function openRelaySocket(instanceId, wsBase, mintToken, localUrl, runnerToken, force = false, onConflict, onOpen) {
   let backoffMs = 1e3;
   let reconnecting = false;
   let closed = false;
+  let opened = false;
   let socket = null;
   let retryTimer = null;
   const connect = async () => {
@@ -1312,7 +1448,10 @@ function openRelaySocket(instanceId, wsBase, mintToken, localUrl, runnerToken, f
     socket = ws;
     ws.onopen = () => {
       backoffMs = 1e3;
+      const reconnect = opened;
+      opened = true;
       writeLine(`Relay connected: ${instanceId.slice(0, 8)}\u2026`);
+      void Promise.resolve(onOpen?.(instanceId, reconnect)).catch(() => void 0);
     };
     ws.onmessage = async (event) => {
       const text = typeof event.data === "string" ? event.data : String(event.data);
@@ -1599,31 +1738,42 @@ function printLogo(version2) {
   console.log(pad + d("  Browser runner") + (version2 ? d(`  \xB7  v${version2}`) : ""));
   console.log("");
 }
+var STATUS_ROWS = {
+  runner: { label: "Browser", ok: "running on your computer", busy: "starting up\u2026", bad: "stopped \u2014 press r to retry" },
+  tunnel: { label: "Secure link", ok: "connected to ProAgentStore", busy: "opening\u2026", bad: "offline" },
+  pags: { label: "ProAgentStore", ok: "connected \u2014 ready for jobs", busy: "registering\u2026", bad: "not registered (retries automatically)" }
+};
+var LABEL_WIDTH = Math.max(...Object.values(STATUS_ROWS).map((r) => r.label.length)) + 2;
 function describe(kind, s) {
   const ok = s === "online" || s === "registered";
   const busy = s === "starting" || s === "pending";
   const icon = ok ? chalk.green("\u2713") : busy ? chalk.yellow("\u2026") : chalk.red("\u2717");
-  const map = {
-    runner: { label: "Browser", ok: "running on your computer", busy: "starting up\u2026", bad: "stopped \u2014 press r to retry" },
-    tunnel: { label: "Secure link", ok: "connected to ProAgentStore", busy: "opening\u2026", bad: "offline" },
-    pags: { label: "ProAgentStore", ok: "connected \u2014 ready for jobs", busy: "registering\u2026", bad: "not registered (retries automatically)" }
-  };
-  const m = map[kind];
+  const m = STATUS_ROWS[kind];
   return { icon, label: m.label, note: ok ? m.ok : busy ? m.busy : m.bad };
 }
+function connectingNote(elapsedMs) {
+  if (elapsedMs < 3e4) return "Setting things up\u2026 this takes a few seconds. Keep this window open.";
+  const mins = Math.floor(elapsedMs / 6e4);
+  const elapsed = mins >= 1 ? `${mins}m` : `${Math.floor(elapsedMs / 1e3)}s`;
+  return `Still connecting \u2014 ${elapsed} elapsed. Press l for logs.`;
+}
+function pagsNote(registration, heartbeat) {
+  if (registration !== "registered" || heartbeat !== "failing") return void 0;
+  return "registered \u2014 but the heartbeat is failing, so the website reads this machine as offline";
+}
 function printStatus(state) {
   clearScreen();
   printLogo(state.version);
   const connected = state.runner === "online" && state.tunnel === "online" && state.registration === "registered";
   console.log(pad + d("Signed in as ") + w(state.user) + d("  \xB7  agent: ") + w(state.activeInstance) + d("  \xB7  node: ") + w(hostname4()));
   console.log("");
-  const row = (kind, s) => {
+  const row = (kind, s, override) => {
     const { icon, label, note } = describe(kind, s);
-    console.log(pad + icon + " " + w(label.padEnd(13)) + d(note));
+    console.log(pad + icon + " " + w(label.padEnd(LABEL_WIDTH)) + d(override ?? note));
   };
   row("runner", state.runner);
   row("tunnel", state.tunnel);
-  row("pags", state.registration);
+  row("pags", state.registration, pagsNote(state.registration, state.heartbeat));
   console.log("");
   if (connected) {
     console.log(pad + chalk.green("\u2713 You're all set!") + d(" Your agent can now act on the web."));
@@ -1635,7 +1785,7 @@ function printStatus(state) {
     console.log("");
     console.log(pad + d("The website can take a few seconds to show \u201Conline\u201D \u2014 that's normal."));
   } else {
-    console.log(pad + d("Setting things up\u2026 this takes a few seconds. Keep this window open."));
+    console.log(pad + d(connectingNote(state.startedAt ? Date.now() - state.startedAt : 0)));
     if (state.lastEvent) console.log(pad + d("Status: ") + d(state.lastEvent));
   }
   console.log("");
@@ -1708,9 +1858,13 @@ var upCommand = new Command8("up").description("Start the browser runner for all
     tunnel: "offline",
     tunnelUrl: "",
     registration: "pending",
+    heartbeat: "ok",
     lastEvent: "Fetching instances...",
     taskCount: 0,
-    version: CLI_VERSION2
+    version: CLI_VERSION2,
+    // What "a few seconds" is measured against: a state that never resolves was described
+    // as taking a few seconds, indefinitely, because nothing counted (#497).
+    startedAt: Date.now()
   };
   clearScreen();
   printLogo(CLI_VERSION2);
@@ -1773,6 +1927,19 @@ var upCommand = new Command8("up").description("Start the browser runner for all
       if (!trimmed) continue;
       logs.push(trimmed);
       if (logs.length > 200) logs.shift();
+      const status = parseStatusLine(trimmed);
+      if (status) {
+        if (status.registration) {
+          state.registration = status.registration === "ok" ? "registered" : "failed";
+          state.lastEvent = status.registration === "ok" ? `Registered with PAGS \u2014 ${status.agents ?? "all"} agents ready` : `PAGS registration ${status.registration}${status.agents ? ` (${status.agents} agents)` : ""}${status.reason ? `: ${status.reason}` : ""}`;
+        }
+        if (status.heartbeat) {
+          state.heartbeat = status.heartbeat === "ok" ? "ok" : "failing";
+          state.lastEvent = status.heartbeat === "ok" ? "Heartbeat recovered \u2014 this machine reads as online again" : `Heartbeat failing${status.reason ? `: ${status.reason}` : ""} \u2014 the console will show this machine offline`;
+        }
+        printStatus(state);
+        continue;
+      }
       if (trimmed.includes("Relay connected:")) {
         state.tunnel = "online";
         state.tunnelUrl = "WebSocket relay";
@@ -1783,7 +1950,6 @@ var upCommand = new Command8("up").description("Start the browser runner for all
       if (trimmed.includes("WebSocket relay")) {
         state.tunnel = "online";
         state.tunnelUrl = "WebSocket relay";
-        state.registration = "registered";
         state.lastEvent = "Connected via WebSocket relay";
         printStatus(state);
         continue;
@@ -1794,21 +1960,13 @@ var upCommand = new Command8("up").description("Start the browser runner for all
         printStatus(state);
         continue;
       }
-      if (trimmed.includes("Runtime registered") || trimmed.includes("CONNECTED")) {
-        state.registration = "registered";
-        state.lastEvent = "Registered with PAGS \u2014 ready for tasks";
-        printStatus(state);
-        continue;
-      }
-      if (trimmed.includes("Another machine")) {
-        state.registration = "failed";
-        state.lastEvent = trimmed.slice(0, 80);
+      if (trimmed.includes("Relay conflict:")) {
+        state.lastEvent = "Another runner holds this agent \u2014 run `pags up --force` here to take it over";
         printStatus(state);
         continue;
       }
-      if (trimmed.includes("fetch failed")) {
-        state.registration = "failed";
-        state.lastEvent = "PAGS registration failed";
+      if (trimmed.includes("Relay conflict cleared:")) {
+        state.lastEvent = "Relay conflict cleared \u2014 reattaching";
         printStatus(state);
         continue;
       }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@proagentstore/cli",
-  "version": "0.4.45",
+  "version": "0.4.47",
   "description": "CLI for creating, publishing, and running ProAgentStore agents",
   "license": "MIT",
   "type": "module",