pushary 1.9.56 → 1.9.58

package/dist/chunk-CZULJ647.js

@@ -0,0 +1,378 @@
+import {
+  callMcpTool
+} from "./chunk-ZL3UR6M5.js";
+import {
+  NPX_LATEST_COMMAND
+} from "./chunk-5SFM6XB4.js";
+import {
+  classifyConfirmResponse,
+  isAnswerSource
+} from "./chunk-GZL3KEPC.js";
+
+// src/reach.ts
+var reachVerdict = (channels) => {
+  const { yours, site } = channels;
+  if (yours === null || site === null) {
+    return channels.phoneReachable || channels.webActive > 0 ? { kind: "yours" } : { kind: "nobody" };
+  }
+  if (yours.phoneReachable) return { kind: "yours" };
+  const solo = site.otherMembers === 0;
+  if (solo) {
+    return site.phoneReachable || site.webActive > 0 ? { kind: "yours" } : { kind: "nobody" };
+  }
+  if (site.appDevices === 0 && site.webActive === 0) return { kind: "nobody" };
+  if (site.webActive > 0 && !yours.webAttributable) {
+    return { kind: "unattributable", otherMembers: site.otherMembers };
+  }
+  return { kind: "others", otherMembers: site.otherMembers };
+};
+var reachesYou = (channels) => reachVerdict(channels).kind === "yours";
+var plural = (count, one, many = `${one}s`) => `${count} ${count === 1 ? one : many}`;
+var describeReach = (channels) => {
+  const verdict = reachVerdict(channels);
+  if (verdict.kind === "nobody") return "nothing can receive an approval";
+  const parts = [];
+  const own = channels.yours;
+  if (verdict.kind === "yours" && own !== null && own.appDevices > 0) {
+    const platforms = own.appPlatforms.length > 0 ? ` (${own.appPlatforms.join(", ")})` : "";
+    parts.push(`${plural(own.appDevices, "app device")}${platforms}`);
+  } else if (channels.appDevices > 0) {
+    const platforms = channels.appPlatforms.length > 0 ? ` (${channels.appPlatforms.join(", ")})` : "";
+    parts.push(`${plural(channels.appDevices, "app device")}${platforms}`);
+  }
+  if (channels.webPhone > 0) parts.push(`${plural(channels.webPhone, "browser")} on a phone`);
+  if (channels.webDesktop > 0) parts.push(`${plural(channels.webDesktop, "browser")} on a desktop`);
+  const summary = parts.length > 0 ? parts.join(", ") : "a device";
+  if (verdict.kind === "others") return `${summary}, none of them yours`;
+  if (verdict.kind === "unattributable") return `${summary}, and no way to tell whose`;
+  return summary;
+};
+var describeAppRepair = (verdict) => {
+  switch (verdict.kind) {
+    case "yours":
+      return null;
+    case "nobody":
+      return [
+        "Open the Pushary app, sign in, and allow notifications.",
+        `If this terminal was never paired with your phone, run: ${NPX_LATEST_COMMAND} setup --connect app`
+      ];
+    case "others":
+      return [
+        `Reachable devices belong to other members of this workspace (${verdict.otherMembers}).`,
+        "Sign in on the Pushary app with your own account so approvals can reach you."
+      ];
+    case "unattributable":
+      return [
+        "Something is reachable here, but not identifiably yours.",
+        "Sign in on the Pushary app so your approvals are routed to your device."
+      ];
+  }
+};
+var describeJustPairedRepair = (verdict) => {
+  if (verdict.kind === "nobody") {
+    return [
+      "The app asks for the notification permission after it grants the pairing.",
+      "Open the Pushary app and allow notifications. That is the whole remaining step."
+    ];
+  }
+  return describeAppRepair(verdict) ?? [];
+};
+
+// src/setup/verify.ts
+var plural2 = (count, one) => `${count} ${one}${count === 1 ? "" : "s"}`;
+var SETUP_AGENT_NAME = "Pushary setup";
+var ownAppPlatforms = (channels) => channels.yours?.appPlatforms ?? channels.appPlatforms;
+var describeRecipients = (push, channels) => {
+  const parts = [];
+  if (push.app > 0) {
+    const platforms = ownAppPlatforms(channels);
+    const suffix = platforms.length > 0 ? ` (${platforms.join(", ")})` : "";
+    parts.push(`${plural2(push.app, "app device")}${suffix}`);
+  }
+  if (push.web > 0) parts.push(plural2(push.web, "browser"));
+  return parts.length > 0 ? parts.join(" and ") : plural2(push.total, "device");
+};
+var classifyDelivery = (channels, push) => {
+  if (push.total <= 0) return { kind: "no-recipients" };
+  const verdict = reachVerdict(channels);
+  if (verdict.kind === "yours" && (push.app > 0 || channels.yours === null || channels.site?.otherMembers === 0)) {
+    return { kind: "delivered", recipients: push.total, deviceLabel: describeRecipients(push, channels) };
+  }
+  if (verdict.kind === "unattributable") {
+    return { kind: "unattributable", recipients: push.total, otherMembers: verdict.otherMembers };
+  }
+  if (verdict.kind === "others") {
+    return { kind: "others-only", recipients: push.total, otherMembers: verdict.otherMembers };
+  }
+  if (verdict.kind === "yours") {
+    const otherMembers = channels.site?.otherMembers ?? 0;
+    return { kind: "unattributable", recipients: push.total, otherMembers };
+  }
+  return { kind: "delivered", recipients: push.total, deviceLabel: describeRecipients(push, channels) };
+};
+var sendTestNotification = async (apiKey) => {
+  const result = await callMcpTool(apiKey, "send_notification", {
+    title: "Pushary is connected",
+    body: "This setup notification reached you. Agent hooks still need a real-agent check.",
+    agentName: SETUP_AGENT_NAME
+  }, { timeoutMs: 2e4 });
+  const toCount = (value) => typeof value === "number" && Number.isFinite(value) ? value : 0;
+  const app = toCount(result.delivery?.mobile?.recipients);
+  const web = toCount(result.delivery?.web?.recipients);
+  return { app, web, total: typeof result.sent === "number" ? result.sent : app + web };
+};
+var verifyDelivery = async (apiKey, channels, deps = {}) => {
+  const send = deps.send ?? sendTestNotification;
+  try {
+    return classifyDelivery(channels, await send(apiKey));
+  } catch (err) {
+    return { kind: "error", detail: err instanceof Error ? err.message : "send failed" };
+  }
+};
+var describeVerifyOutcome = (outcome) => {
+  switch (outcome.kind) {
+    case "delivered":
+      return { ok: true, message: `Delivered to ${outcome.deviceLabel}. Push works.`, next: [] };
+    case "no-recipients":
+      return {
+        ok: false,
+        message: "Nothing to deliver to. Agents are configured; approvals will fall back to the terminal.",
+        next: [
+          "Run pushary pair to pair your phone.",
+          "Then pushary doctor --roundtrip to test a synthetic question and answer."
+        ]
+      };
+    case "others-only":
+      return {
+        ok: false,
+        message: `Delivered to ${plural2(outcome.recipients, "device")} on this site, none of them yours.`,
+        next: [
+          `Approvals for your agent would wake one of your ${plural2(outcome.otherMembers, "teammate")}.`,
+          "Run pushary pair to pair your own phone."
+        ]
+      };
+    case "unattributable":
+      return {
+        ok: false,
+        message: `Delivered to ${plural2(outcome.recipients, "device")} on this site, and no way to tell whose.`,
+        next: [
+          "Browser subscriptions carry no owner, and this site has other members.",
+          "Install the Pushary app and pair it with pushary pair, or run pushary doctor --roundtrip to prove it reaches you."
+        ]
+      };
+    case "error":
+      return {
+        ok: false,
+        message: `Could not send the test notification (${outcome.detail}).`,
+        next: ["Agents are configured. Run pushary doctor once the connection is back."]
+      };
+  }
+};
+var ROUND_TRIP_QUESTION = "Pushary delivery test. Answer either way to test returning an answer. This does not test your agent hooks.";
+var ROUND_TRIP_TIMEOUT_MS = 55e3;
+var reportNoInterrupt = async () => {
+};
+var defaultAsk = (apiKey, agentName) => (
+  // wait:false so the poll is ours: the blocking form returns on the SITE's
+  // policy timeout, which a user may have set to seconds, and a setup check
+  // reporting "unanswered" after three seconds would be a lie about the product.
+  callMcpTool(apiKey, "ask_user", {
+    question: ROUND_TRIP_QUESTION,
+    type: "confirm",
+    agentName,
+    wait: false
+  }, { timeoutMs: 15e3 })
+);
+var defaultWait = (apiKey, correlationId) => callMcpTool(apiKey, "wait_for_answer", {
+  correlationId,
+  timeoutMs: ROUND_TRIP_TIMEOUT_MS
+}, { timeoutMs: ROUND_TRIP_TIMEOUT_MS + 5e3 });
+var defaultCancel = async (apiKey, correlationId) => {
+  await callMcpTool(apiKey, "cancel_question", { correlationId }, { timeoutMs: 1e4 }).catch(() => {
+  });
+};
+var answeredRoundTrip = (answer, correlationId, latencyMs) => {
+  if (answer.value === void 0 || classifyConfirmResponse(answer.value) === null) {
+    return { kind: "error", detail: "the server reported an answer without a valid Yes, No or defer value" };
+  }
+  return {
+    kind: "answered",
+    value: answer.value,
+    latencyMs,
+    correlationId,
+    ...isAnswerSource(answer.answerSource) ? { answerSource: answer.answerSource } : {}
+  };
+};
+var verifyRoundTrip = async (apiKey, agentName = SETUP_AGENT_NAME, deps = {}) => {
+  const ask = deps.ask ?? defaultAsk;
+  const wait = deps.wait ?? defaultWait;
+  const cancel = deps.cancel ?? defaultCancel;
+  const interrupted = deps.interrupted ?? reportNoInterrupt;
+  const now = deps.now ?? Date.now;
+  const started = now();
+  let asked;
+  try {
+    asked = await ask(apiKey, agentName);
+  } catch (err) {
+    return { kind: "error", detail: err instanceof Error ? err.message : "ask failed" };
+  }
+  let shutdown;
+  const stop = (code) => {
+    if (shutdown) return;
+    shutdown = (async () => {
+      let timer;
+      try {
+        await Promise.race([
+          Promise.all([
+            cancel(apiKey, asked.correlationId).catch(() => {
+            }),
+            interrupted(code).catch(() => {
+            })
+          ]),
+          new Promise((resolve) => {
+            timer = setTimeout(resolve, 4e3);
+          })
+        ]);
+      } finally {
+        clearTimeout(timer);
+        process.stderr.write("Delivery test interrupted. Cleanup was attempted; an unresolved question expires automatically.\n");
+        process.exit(code);
+      }
+    })();
+  };
+  const onInterrupt = () => stop(130);
+  const onTerminate = () => stop(143);
+  if (asked.correlationId) {
+    process.on("SIGINT", onInterrupt);
+    process.on("SIGTERM", onTerminate);
+  }
+  let answerObserved = false;
+  try {
+    if (asked.noDevices || asked.warning) return { kind: "no-recipients" };
+    if (asked.mode === "notify_only" || asked.status === "notified") return { kind: "notify-only" };
+    if (!asked.correlationId) return { kind: "error", detail: "no correlationId returned" };
+    const answer = asked.answered === true ? asked : await wait(apiKey, asked.correlationId);
+    if (answer.answered === true) {
+      const outcome = answeredRoundTrip(answer, asked.correlationId, now() - started);
+      answerObserved = outcome.kind === "answered";
+      return outcome;
+    }
+    return { kind: "unanswered" };
+  } catch (err) {
+    return { kind: "error", detail: err instanceof Error ? err.message : "wait failed" };
+  } finally {
+    if (shutdown) await shutdown;
+    process.off("SIGINT", onInterrupt);
+    process.off("SIGTERM", onTerminate);
+    if (!answerObserved && asked.correlationId) await cancel(apiKey, asked.correlationId).catch(() => {
+    });
+  }
+};
+var describeAnswerSource = (source) => {
+  switch (source) {
+    case "mobile_app":
+    case "mobile_background":
+      return "Answered on your phone.";
+    case "mac_app":
+      return "Answered on your Mac.";
+    case "sandbox":
+      return "This was a simulated sandbox answer.";
+    default:
+      return source ? `Answer source: ${source}. This was a synthetic test.` : "The answering surface was not reported. This was a synthetic test.";
+  }
+};
+var NOTIFICATION_ANSWER_STEPS = /* @__PURE__ */ new Map([
+  ["ios", "Press and hold the notification, then tap Approve."],
+  ["android", "Expand the notification, then tap Approve."]
+]);
+var EITHER_PHONE_ANSWER_STEP = "Press and hold the notification on iPhone, or expand it on Android, then tap Approve.";
+var notificationAnswerStep = (appPlatforms) => {
+  const platforms = [...new Set(appPlatforms)];
+  const [onlyPlatform] = platforms;
+  if (onlyPlatform === void 0) return null;
+  if (platforms.length > 1) return EITHER_PHONE_ANSWER_STEP;
+  return NOTIFICATION_ANSWER_STEPS.get(onlyPlatform) ?? EITHER_PHONE_ANSWER_STEP;
+};
+var WAITING_FOR_TAP = "Waiting for you to tap the notification";
+var WAITING_FOR_ANSWER = "Waiting for your answer";
+var describeAnswerTestPrompt = (appPlatforms) => {
+  const step = notificationAnswerStep(appPlatforms);
+  return { step, waiting: step === null ? WAITING_FOR_TAP : WAITING_FOR_ANSWER };
+};
+var CHECK_THE_NOTIFICATION_OPENED = "Check the notification actually opened something you could tap, then run pushary doctor --roundtrip.";
+var unansweredNextStep = (appPlatforms) => {
+  const step = notificationAnswerStep(appPlatforms);
+  return step === null ? CHECK_THE_NOTIFICATION_OPENED : `To send another one, run pushary doctor --roundtrip. ${step}`;
+};
+var describeRoundTripOutcome = (outcome, appPlatforms = []) => {
+  switch (outcome.kind) {
+    case "answered":
+      return {
+        ok: true,
+        message: `Answered "${outcome.value}" in ${(outcome.latencyMs / 1e3).toFixed(1)}s. ${describeAnswerSource(outcome.answerSource)}`,
+        next: []
+      };
+    case "unanswered":
+      return {
+        ok: false,
+        message: "The question was sent and nothing came back.",
+        next: [
+          "A push that arrives and cannot be answered is the most common way this breaks, so this is worth resolving now.",
+          unansweredNextStep(appPlatforms)
+        ]
+      };
+    case "notify-only":
+      return {
+        ok: true,
+        message: "Sent. This site is in notify-only mode, so questions never wait for an answer.",
+        next: ["Switch with pushary mode push_first if you want approvals to hold for your phone."]
+      };
+    case "no-recipients":
+      return {
+        ok: false,
+        message: "Nothing to ask. No phone or browser is connected to this site.",
+        next: [
+          "Run pushary pair to pair your phone.",
+          "Or pushary pair --app if you already have the Pushary app."
+        ]
+      };
+    case "error":
+      return {
+        ok: false,
+        message: `Could not complete the round trip (${outcome.detail}).`,
+        next: ["Agents are configured. Run pushary doctor --roundtrip once the connection is back."]
+      };
+  }
+};
+var describeRoundTrip = (outcome, appPlatforms = []) => {
+  const report = describeRoundTripOutcome(outcome, appPlatforms);
+  return { ...report, next: [...report.next, "Agent hook activation remains unverified. Restart your agent and check one real approval."] };
+};
+var roundTripEvidence = (outcome) => ({
+  kind: outcome?.kind ?? "skipped",
+  ...outcome?.kind === "answered" ? {
+    correlationId: outcome.correlationId ?? null,
+    answerSource: outcome.answerSource ?? null,
+    value: outcome.value,
+    latencyMs: outcome.latencyMs
+  } : {},
+  hookActivation: "unverified"
+});
+
+export {
+  reachVerdict,
+  reachesYou,
+  describeReach,
+  describeAppRepair,
+  describeJustPairedRepair,
+  SETUP_AGENT_NAME,
+  ownAppPlatforms,
+  verifyDelivery,
+  describeVerifyOutcome,
+  verifyRoundTrip,
+  notificationAnswerStep,
+  describeAnswerTestPrompt,
+  describeRoundTripOutcome,
+  describeRoundTrip,
+  roundTripEvidence
+};

package/dist/{chunk-J5HQNZXQ.js → chunk-DQ565WFA.js}

@@ -1,7 +1,7 @@
 import {
   SubscriptionRequiredError,
   callMcpTool
-} from "./chunk-WCPN3GVW.js";
+} from "./chunk-ZL3UR6M5.js";
 import {
   CLIENT_REPORT_DISABLE_ENV,
   isDisabledByEnv
@@ -9,14 +9,14 @@ import {
 import {
   installNetworkDefaults,
   isNetworkFailure
-} from "./chunk-32MSOGMD.js";
+} from "./chunk-5DZHKNBU.js";
 import {
   clientReportClaims
-} from "./chunk-57EOP757.js";
+} from "./chunk-MYBCXDIL.js";
 import {
   getApiKey,
   getBaseUrl
-} from "./chunk-MWBFB7WA.js";
+} from "./chunk-LVDC3RUE.js";
 import {
   ASK_AGENT_NAME_MAX,
   CLIENT_REPORT_PATH,
@@ -24,7 +24,7 @@ import {
   GATE_PERMISSION_MODE_MAX_LENGTH,
   degradedLine,
   truncateLine
-} from "./chunk-WACFIQYA.js";
+} from "./chunk-GZL3KEPC.js";
 
 // src/api.ts
 import { randomUUID } from "crypto";

package/dist/{chunk-ZMRO6ESW.js → chunk-ECJJKDP7.js}

@@ -10,7 +10,7 @@ import {
   isSetupConnectMode,
   isValidApiKey,
   normalizeAgentId
-} from "./chunk-WACFIQYA.js";
+} from "./chunk-GZL3KEPC.js";
 
 // src/setup/options.ts
 var AGENT_CHOICES = SETUP_AGENT_CHOICES;

package/dist/chunk-FAGDOPQI.js

@@ -0,0 +1,266 @@
+import {
+  notificationAnswerStep
+} from "./chunk-CZULJ647.js";
+import {
+  matchMacAccountStep,
+  retryAgentCommand
+} from "./chunk-HUWLEVL2.js";
+import {
+  EXIT
+} from "./chunk-KZERVKTD.js";
+import {
+  NPX_LATEST_COMMAND
+} from "./chunk-5SFM6XB4.js";
+
+// src/setup/closing.ts
+var ACTIVITY_URL = "pushary.com/dashboard/agent/activity";
+var CHECK_THE_NOTIFICATION_OPENED = "Check the notification opened something you could tap, then:";
+var SEND_ANOTHER_TEST = "pushary doctor --roundtrip   send another one";
+var sendAnotherTestLines = (appPlatforms) => {
+  const step = notificationAnswerStep(appPlatforms);
+  return step === null ? [CHECK_THE_NOTIFICATION_OPENED, SEND_ANOTHER_TEST] : [SEND_ANOTHER_TEST, step];
+};
+var TRANSCRIPT_SYNC_NOTICE = `Transcripts sync redacted and encrypted. Your phone can decrypt them; authorized Pushary compliance admins can recover them for documented legal obligations. Turn off: ${NPX_LATEST_COMMAND} setup --transcripts off`;
+var PAIR_PHONE_APP_HINT = `${NPX_LATEST_COMMAND} setup --connect app   pair the Pushary app on your phone`;
+var RESTART_AGENTS_LINE = "Restart any open agent sessions so they pick up Pushary.";
+var ANSWERING_DEVICES = {
+  mobile_app: "Your phone",
+  mobile_background: "Your phone",
+  mac_app: "Your Mac"
+};
+var SIMULATED_ANSWER_HEADLINE = "Agents configured. The test answer was simulated.";
+var answerSeconds = (latencyMs) => Math.max(1, Math.round(latencyMs / 1e3));
+var describeAnsweredHeadline = (answer) => {
+  if (!answer) return "You're set. The test question was answered.";
+  if (answer.answerSource === "sandbox") return SIMULATED_ANSWER_HEADLINE;
+  const device = answer.answerSource ? ANSWERING_DEVICES[answer.answerSource] : void 0;
+  const seconds = answerSeconds(answer.latencyMs);
+  return device ? `You're set. ${device} answered in ${seconds}s.` : `You're set. The test question was answered in ${seconds}s.`;
+};
+var COMMAND_SURFACE = [
+  { command: "pushary status", summary: "what this machine is connected to" },
+  { command: "pushary mode", summary: "choose where approval requests appear" },
+  { command: "pushary wait", summary: "show or set how long approvals wait for your phone" },
+  { command: "pushary stats", summary: "what your agents have been asking" },
+  { command: "pushary claude", summary: "run Claude Code with encrypted transcript support" },
+  { command: "pushary doctor", summary: "check the install" }
+];
+var SURFACE_COLUMN = Math.max(...COMMAND_SURFACE.map((entry) => entry.command.length)) + 2;
+var renderCommandSurface = () => COMMAND_SURFACE.map((entry) => `${entry.command.padEnd(SURFACE_COLUMN)}${entry.summary}`);
+var PHONE_START_VERIFIED_LINE = "Phone-start and steering: local and server checks passed just now. Recheck after sleep or network changes.";
+var PHONE_START_UNVERIFIED_LINE = "Phone-start and steering: unverified. Run pushary doctor to check the provider, background service and server route.";
+var PHONE_START_FELL_SHORT_LINES = {
+  not_running: "Phone-start and steering: not running on this computer. Approvals do not depend on it. Run pushary doctor to see what is missing.",
+  running_unverified: "Phone-start and steering: the background service is running, but this run could not verify it. Approvals do not depend on it. Run pushary doctor to check it.",
+  could_not_be_removed: "Phone-start and steering: the background service could not be stopped or removed. Approvals do not depend on it. Run pushary doctor to see its state."
+};
+var phoneStartFellShortLine = (service) => PHONE_START_FELL_SHORT_LINES[service];
+var phoneStartServiceState = (reading) => {
+  if (reading.lifecycleFailed) return "could_not_be_removed";
+  return reading.serviceIsRunning ? "running_unverified" : "not_running";
+};
+var phoneStartStatusLine = (facts) => {
+  if (facts.managedControlReady === true) return PHONE_START_VERIFIED_LINE;
+  if (facts.daemonReady === false) return phoneStartFellShortLine(facts.phoneStartService ?? "not_running");
+  return PHONE_START_UNVERIFIED_LINE;
+};
+var phoneStartFailedTheRun = (facts) => facts.daemonReady === false && facts.phoneStartRequired !== false;
+var PHONE_START_UNVERIFIED_STEPS = [
+  "Agent configuration and managed control are separate. Phone-start and steering could not be verified.",
+  "pushary daemon install   install or repair the background service",
+  "pushary doctor           verify it became reachable"
+];
+var PHONE_START_CANNOT_RUN_LINE = "Agent configuration and managed control are separate. Phone-start cannot run on this computer yet; approvals do not depend on it.";
+var STOP_REQUIRING_PHONE_START_STEP = `${NPX_LATEST_COMMAND} setup --control off   stop requiring phone-start on this computer`;
+var WHAT_PHONE_START_NEEDS = {
+  provider: [
+    "It needs Claude Code, Codex or Gemini CLI set up here with a command it can start, and setup found none.",
+    "It looks for claude, codex and gemini on PATH and in npm's global folder, and for claude in Claude Code's own install folder too.",
+    "Install one, or open a terminal where it runs, then run setup again."
+  ],
+  "service-manager": [
+    "It needs a background service manager (launchd, systemd --user or Windows Task Scheduler), and this session has none.",
+    "Run setup again from a normal desktop session."
+  ]
+};
+var PHONE_START_NOT_REMOVED_STEPS = [
+  PHONE_START_FELL_SHORT_LINES.could_not_be_removed,
+  "pushary doctor           see what state it is in"
+];
+var phoneStartProblemSteps = (facts) => {
+  if (facts.phoneStartService === "could_not_be_removed") return PHONE_START_NOT_REMOVED_STEPS;
+  const missing = facts.phoneStartMissingPrerequisite;
+  return missing ? [PHONE_START_CANNOT_RUN_LINE, ...WHAT_PHONE_START_NEEDS[missing], STOP_REQUIRING_PHONE_START_STEP] : PHONE_START_UNVERIFIED_STEPS;
+};
+var nextSteps = (facts, reachable) => {
+  const lines = ["Delivery follows the current approval mode, recipient rules and presence. pushary mode status shows the workspace setting.", phoneStartStatusLine(facts)];
+  lines.push("Before stepping away, run pushary wait to see how long phone approvals wait and what happens if you do not answer.");
+  if (facts.staleEnvironmentKey) {
+    lines.push("Open a new terminal or unset PUSHARY_API_KEY, then run pushary doctor before starting an agent.");
+  }
+  if (facts.transcriptSync === false) {
+    lines.push("Transcripts: disabled on this machine.");
+    lines.push("pushary setup --transcripts on    enable encrypted transcript sync");
+  } else {
+    lines.push(TRANSCRIPT_SYNC_NOTICE);
+  }
+  if (facts.completed.includes("claude_code")) {
+    lines.push("pushary claude          launch a managed Claude Code session");
+  }
+  if (!reachable) {
+    lines.push(PAIR_PHONE_APP_HINT);
+  }
+  lines.push("pushary doctor          re-check everything");
+  return lines;
+};
+var describeClosing = (facts) => {
+  const reachable = facts.reachChecked && facts.reachesYou;
+  if (facts.configuredNothing) {
+    return {
+      ok: false,
+      headline: "Setup failed.",
+      next: ["Nothing was configured. Run pushary doctor to see why."],
+      exitCode: EXIT.FAILED,
+      reason: "configured-nothing"
+    };
+  }
+  if (facts.failed.length > 0) {
+    const count = facts.failed.length;
+    return {
+      ok: false,
+      headline: `Setup finished with ${count} problem${count === 1 ? "" : "s"}.`,
+      next: [
+        ...nextSteps(facts, reachable),
+        "For support: pushary doctor --bundle creates a redacted diagnostic with the last setup failure. Review it before sharing.",
+        "",
+        `Approvals: ${ACTIVITY_URL}`
+      ],
+      exitCode: EXIT.PROBLEMS_FOUND,
+      reason: "agents-failed"
+    };
+  }
+  if (facts.staleEnvironmentKey) {
+    return {
+      ok: false,
+      headline: "Agents configured. This terminal still selects the previous key.",
+      next: nextSteps(facts, reachable),
+      exitCode: EXIT.PROBLEMS_FOUND,
+      reason: "stale-environment-key"
+    };
+  }
+  if (phoneStartFailedTheRun(facts)) {
+    return {
+      ok: false,
+      headline: "Setup finished with 1 problem.",
+      next: phoneStartProblemSteps(facts),
+      exitCode: EXIT.PROBLEMS_FOUND,
+      reason: "control-unready"
+    };
+  }
+  if (facts.roundTripAnswered === true) {
+    return {
+      ok: true,
+      headline: describeAnsweredHeadline(facts.roundTripAnswer),
+      next: [RESTART_AGENTS_LINE, ...nextSteps(facts, reachable), "", `Approvals: ${ACTIVITY_URL}`],
+      exitCode: EXIT.OK,
+      reason: "synthetic-answer"
+    };
+  }
+  if (facts.reachChecked && !facts.reachesYou) {
+    return {
+      ok: false,
+      headline: "Agents configured. Phone delivery is unverified.",
+      next: [
+        "Your agent configuration is saved. Once your phone is connected, run pushary doctor --roundtrip to finish verification without reinstalling.",
+        "Approval routing depends on your mode, presence and recipients. Check the phone and its notification settings.",
+        "",
+        ...nextSteps(facts, false)
+      ],
+      exitCode: EXIT.NO_DEVICE,
+      reason: "phone-unverified"
+    };
+  }
+  if (facts.roundTripAnswered === false) {
+    return {
+      ok: false,
+      headline: "Agents configured. Nobody answered the test question.",
+      next: [
+        "No answer returned from the synthetic test. Delivery acceptance does not prove a visible notification.",
+        "",
+        ...sendAnotherTestLines(facts.appPlatforms ?? []),
+        "",
+        "If you simply were not looking, re-run setup or pass --verify push to skip this check."
+      ],
+      exitCode: EXIT.PROBLEMS_FOUND,
+      reason: "roundtrip-unanswered"
+    };
+  }
+  if (!facts.reachChecked) {
+    return {
+      ok: true,
+      headline: "Setup complete.",
+      next: [
+        "The phone check was skipped, so nothing here proves an approval reaches you.",
+        "",
+        ...nextSteps(facts, false)
+      ],
+      exitCode: EXIT.OK,
+      reason: "phone-skipped"
+    };
+  }
+  return {
+    ok: true,
+    headline: "Setup complete.",
+    next: [...nextSteps(facts, true), "", `Approvals: ${ACTIVITY_URL}`],
+    exitCode: EXIT.OK,
+    reason: "complete"
+  };
+};
+var RETRY_AGENT_LABEL = "Retry just this agent:";
+var INSTALL_NODE_STEP = "Install the current Node.js LTS, which includes npm, then run setup again.";
+var NPM_PREFIX_STEP = "npm can't install globally here. Use nvm, or run: npm config set prefix ~/.npm-global, then run setup again.";
+var NPM_FILE_IN_USE_STEP = "Close other terminals or editors that use Node, then run setup again.";
+var nextStepFor = (failure) => {
+  switch (failure.remedy) {
+    case "install-node":
+      return { kind: "install-node", instruction: INSTALL_NODE_STEP };
+    case "fix-npm-prefix":
+      return { kind: "fix-npm-prefix", instruction: NPM_PREFIX_STEP };
+    case "close-node-programs":
+      return { kind: "close-node-programs", instruction: NPM_FILE_IN_USE_STEP };
+    case "match-mac-account":
+      return { kind: "match-mac-account", instruction: matchMacAccountStep(failure.agent, null) };
+    case "retry-agent":
+      return { kind: "retry-agent", command: retryAgentCommand(failure.agent) };
+  }
+};
+var describeAgentFailures = (failures, agentName) => failures.map((failure) => ({
+  summary: `${agentName(failure.agent)}: ${failure.detail}`,
+  next: nextStepFor(failure)
+}));
+var agentFailureFollowUps = (failures) => [
+  ...failures.some((failure) => failure.remedy === "install-node") ? ["install-node"] : [],
+  ...failures.some((failure) => failure.remedy === "fix-npm-prefix") ? ["fix-npm-prefix"] : [],
+  ...failures.some((failure) => failure.remedy === "close-node-programs") ? ["close-node-programs"] : [],
+  ...failures.some((failure) => failure.remedy === "retry-agent") ? ["run-doctor"] : []
+];
+var unverifiedKeyClosingReason = (facts) => {
+  if (facts.failedCount > 0) return "agents-failed";
+  if (facts.controlLifecycleFailed) return "control-unready";
+  return facts.keyCheck === "locked" ? "plan-inactive" : "key-unverified";
+};
+
+export {
+  TRANSCRIPT_SYNC_NOTICE,
+  renderCommandSurface,
+  phoneStartFellShortLine,
+  phoneStartServiceState,
+  describeClosing,
+  RETRY_AGENT_LABEL,
+  INSTALL_NODE_STEP,
+  NPM_PREFIX_STEP,
+  NPM_FILE_IN_USE_STEP,
+  describeAgentFailures,
+  agentFailureFollowUps,
+  unverifiedKeyClosingReason
+};