relay-companion 0.1.407 → 0.1.409

package/bin/relay.js

@@ -217,10 +217,8 @@ async function applyInstall({
   requireLiveTools = false,
   requiredHosts = requiredLiveHosts(),
   claim = false,
+  reload = true,
 } = {}) {
-  // Installing or repairing is also the migration point for old local
-  // capability settings. writeConfig sanitizes them before touching disk.
-  writeConfig({});
   const {
     installed,
     missing,
@@ -232,7 +230,7 @@ async function applyInstall({
     codexHooks = null,
     desktopRestarts = [],
     sweptStaleEntries = [],
-  } = await runSetupInstall({ claim });
+  } = await runSetupInstall({ claim, reload });
   if (installed.length) console.log(`Added Relay to ${installed.join(" and ")} on this machine.`);
   if (!binStable) {
     console.log(
@@ -351,6 +349,10 @@ async function cmdSetup(flags) {
     // An explicit setup is the migration/ownership handoff. Runtime verification
     // in runSetupInstall completes before either platform's autostart is changed.
     claim: true,
+    // The signed thin bootstrap asks setup to write all registrations without
+    // starting them, then performs the same exact-root lifecycle as the updater.
+    // Ordinary setup keeps its historical install-and-start behaviour.
+    reload: !(flags["no-restart"] && process.env.RELAY_BOOTSTRAP_ACTIVATED === "1"),
   });
   const token = setupOpenRelayToken(flags);
   if (token && readConfig().deviceToken) {
@@ -389,8 +391,11 @@ async function cmdInstall(flags = {}) {
 }
 
 function cmdRepairDesktop(flags = {}) {
-  writeConfig({});
   const reload = !flags["no-restart"];
+  // Repair is deliberately local and non-destructive. It may rewrite Relay's
+  // launchers and Relay-owned hook registrations, but it never rewrites account
+  // config, deletes credentials/E2EE state, clears messages/outboxes/preferences,
+  // or calls a cloud revocation endpoint.
   // The updater invokes this command from the verified candidate tree before it
   // switches/restarts services. First atomically migrate any existing raw hook
   // registrations to Relay's stable bridge; if that fails, do not claim the
@@ -726,7 +731,7 @@ async function cmdDoctor(flags = {}) {
     const since = failure.firstAt ? new Date(Number(failure.firstAt)).toISOString() : "unknown";
     console.log(`  UPDATES ARE FAILING: ${failure.count} consecutive attempt(s) to install ${failure.target} since ${since}`);
     console.log(`    cause: see ${updateLogPath}`);
-    console.log("    if autostart is broken, run: relay repair-desktop");
+    console.log("    if autostart is broken, run: relay repair-installation");
   } else if (failureInFlight) {
     console.log(`  update attempt in flight: ${failure.target} (launched ${new Date(Number(failure.lastAt)).toISOString()})`);
   } else if (!canonicalFailures.length) {
@@ -786,7 +791,7 @@ async function cmdDoctor(flags = {}) {
     const missingTasks = taskStatus.missing;
     if (missingTasks.length) {
       console.log(`  MISSING Scheduled Task(s): ${missingTasks.join(", ")}`);
-      console.log("    fix with: relay repair-desktop");
+      console.log("    fix with: relay repair-installation");
     } else if (taskStatus.unavailable.length) {
       console.log("  Scheduled Tasks: unable to verify from this process");
       console.log("    run relay doctor in a normal terminal to check autostart");
@@ -795,7 +800,7 @@ async function cmdDoctor(flags = {}) {
     // Windows 11 overflow chevron) is the only way back to the pill.
     if (windowsStartMenuShortcutMissing()) {
       console.log(`  MISSING Start Menu shortcut: ${windowsStartMenuShortcutPath()}`);
-      console.log("    fix with: relay repair-desktop");
+      console.log("    fix with: relay repair-installation");
     } else {
       console.log("  Start Menu shortcut: ok (Start → \"relay\" opens the pill)");
     }
@@ -876,9 +881,8 @@ function cmdEnv(positional = [], flags = {}) {
 
 function cmdUpdateChannel(positional = []) {
   const requested = String(positional[0] || "").trim().toLowerCase();
-  const overridden = Boolean(process.env.RELAY_UPDATE_CHANNEL);
   if (!requested) {
-    const source = overridden ? " (from RELAY_UPDATE_CHANNEL)" : "";
+    const source = process.env.RELAY_UPDATE_CHANNEL ? " (from RELAY_UPDATE_CHANNEL)" : "";
     console.log(`[relay] update channel: ${updateChannel()}${source}`);
     console.log(`[relay] switch with: relay update-channel ${UPDATE_CHANNEL_DEV} | relay update-channel ${UPDATE_CHANNEL_STAGING} | relay update-channel ${UPDATE_CHANNEL_STABLE}`);
     return;
@@ -888,18 +892,13 @@ function cmdUpdateChannel(positional = []) {
     process.exitCode = 1;
     return;
   }
-  writeConfig({ updateChannel: requested });
-  if (overridden) {
-    console.log(`[relay] saved channel ${requested}, but RELAY_UPDATE_CHANNEL=${process.env.RELAY_UPDATE_CHANNEL} overrides it in this environment`);
-    return;
-  }
-  if (requested === UPDATE_CHANNEL_DEV) {
-    console.log("[relay] update channel set to dev — this machine now installs builds deliberately promoted for dev testing (usually within a minute of the daemon's next check)");
-  } else if (requested === UPDATE_CHANNEL_STAGING) {
-    console.log("[relay] update channel set to staging — this machine now installs production-like release candidates deliberately promoted to staging");
-  } else {
-    console.log("[relay] update channel set to stable — this machine keeps its current build and follows production releases from here on");
-  }
+  // Release code and its server contract are one environment. Keeping these as
+  // independent switches allowed a dev Companion to keep calling production,
+  // where unreleased routes (notably Slack) correctly do not exist. Preserve
+  // the old command as an alias, but make the resulting state coherent.
+  if (requested === UPDATE_CHANNEL_DEV) return cmdEnv(["dev"]);
+  if (requested === UPDATE_CHANNEL_STAGING) return cmdEnv(["staging"]);
+  if (requested === UPDATE_CHANNEL_STABLE) return cmdEnv(["prod"]);
 }
 
 async function cmdE2eeHistoryImport(flags) {
@@ -974,6 +973,7 @@ async function main() {
       return cmdPair(flags);
     case "install":
       return cmdInstall(flags);
+    case "repair-installation":
     case "repair-desktop":
       return cmdRepairDesktop(flags);
     case "repair-runtime":
@@ -1048,7 +1048,8 @@ async function main() {
           "  relay install                                        Add Relay to your agents",
           "  relay uninstall                                       Remove Relay from your agents and stop the daemon (keeps the pairing)",
           "  relay uninstall --purge                               Also revoke this device and delete all local Relay state, as if never installed",
-          "  relay repair-desktop [--no-restart]                  Repair Relay.app and background services without changing MCP/account state",
+          "  relay repair-installation [--no-restart]             Non-destructively repair Relay.app and services; preserves account, encryption, messages, outbox, and preferences",
+          "  relay repair-desktop [--no-restart]                  Compatibility alias for repair-installation",
           "  relay repair-runtime [--no-restart]                  Internal: refresh existing Relay registrations and runtime services",
           "  relay pair [--api URL] [--web URL] [--code CODE] [--no-restart] Pair this machine only (no agent install); restarts running Relay services onto the new account",
           "  relay tasks                                           Pull and process the developer Request runtime once",

package/bootstrap/relay-setup.cjs

@@ -11,7 +11,8 @@ const os = require("node:os");
 const path = require("node:path");
 const { spawnSync } = require("node:child_process");
 const { pipeline } = require("node:stream/promises");
-const { exactRuntimeHealth } = require("./runtime-health.cjs");
+const { activateMacRuntimeServices, exactRuntimeHealth } = require("./runtime-health.cjs");
+const { verifyRuntimeExecutables } = require("./runtime-executables.cjs");
 
 const RELEASE_ORIGIN = "https://api.sendrelays.com";
 const RELEASE_BASE_PATH = "/v1/companion-releases";
@@ -19,7 +20,7 @@ const PACKAGE_NAME = "relay-companion";
 const WINDOWS_RELAY_TASKS = ["Relay Companion Pill", "Relay Companion Daemon"];
 const WINDOWS_STOP_RELAY_SERVICES_PS = [
   "$p=Get-CimInstance Win32_Process -ErrorAction SilentlyContinue | Where-Object {",
-  "  $_.CommandLine -and (($_.CommandLine -match '[\\\\/]relay\\.js.*\\bdaemon\\b') -or ($_.CommandLine -match '[\\\\/]overlay[\\\\/]main\\.cjs'))",
+  "  $_.CommandLine -and ($_.CommandLine -match '[\\\\/]node_modules[\\\\/]relay-companion[\\\\/]') -and (($_.CommandLine -match '[\\\\/]relay\\.js.*\\bdaemon\\b') -or ($_.CommandLine -match '[\\\\/]overlay[\\\\/]main\\.cjs'))",
   "}; foreach($x in $p){ try { Invoke-CimMethod -InputObject $x -MethodName Terminate -ErrorAction Stop | Out-Null } catch {} }",
 ].join(" ");
 const packageJson = require("../package.json");
@@ -426,11 +427,21 @@ function verifyExtractedRuntime(packageRoot, version, platformKey) {
   }
   const manifest = JSON.parse(fs.readFileSync(path.join(packageRoot, "package.json"), "utf8"));
   if (manifest.name !== PACKAGE_NAME || manifest.version !== version) fail("Relay runtime package identity is invalid.");
-  const electron = platformKey.startsWith("win32-")
-    ? path.join(path.dirname(packageRoot), "electron", "dist", "electron.exe")
-    : path.join(path.dirname(packageRoot), "electron", "dist", "Electron.app", "Contents", "MacOS", "Electron");
-  if (!fs.statSync(electron, { throwIfNoEntry: false })?.isFile()) fail("Relay runtime has no verified native Electron executable.");
-  return { packageRoot, bin: path.join(packageRoot, "bin", "relay.js"), electron };
+  const bin = path.join(packageRoot, "bin", "relay.js");
+  if (!platformKey.startsWith("win32-")) {
+    try { fs.accessSync(bin, fs.constants.X_OK); }
+    catch { fail("Relay runtime CLI is not executable."); }
+  }
+  const executables = verifyRuntimeExecutables(packageRoot, { platform: platformKey });
+  if (!executables.ok) {
+    fail(`Relay runtime executable verification failed (${executables.reason}${executables.detail ? `: ${executables.detail}` : ""}).`);
+  }
+  return {
+    packageRoot,
+    bin,
+    electron: executables.electronPath,
+    executablePaths: executables.paths.map((entry) => entry.path),
+  };
 }
 
 function runtimeLayout(version, platformKey) {
@@ -586,6 +597,7 @@ function stopPreviousWindowsRuntime({ platform = process.platform, spawnImpl = s
 
 async function activateRuntime(layout, runtime, version, {
   platform = process.platform,
+  homeDir = os.homedir(),
   spawnImpl = spawnSync,
   existsSync = fs.existsSync,
   readFileSync = fs.readFileSync,
@@ -595,6 +607,9 @@ async function activateRuntime(layout, runtime, version, {
   healthAttempts = 60,
   healthIntervalMs = 500,
   sleep,
+  activateMacServices = activateMacRuntimeServices,
+  activationDeadlineMs = 90_000,
+  now = Date.now,
 } = {}) {
   let previous = null;
   try { previous = JSON.parse(readFileSync(layout.pointerPath, "utf8")); } catch {}
@@ -674,7 +689,12 @@ async function activateRuntime(layout, runtime, version, {
     fail(message);
   }
 
-  const result = spawnImpl(process.execPath, [runtime.bin, "setup", "--no-trampoline", "--claim"], {
+  // On macOS setup owns registration, but the shared activation state machine
+  // owns service restart. This keeps first-install MCP/plist creation in the
+  // candidate while bootstrap and the updater use the same exact-root handoff.
+  const setupArgs = [runtime.bin, "setup", "--no-trampoline", "--claim"];
+  if (platform === "darwin") setupArgs.push("--no-restart");
+  const result = spawnImpl(process.execPath, setupArgs, {
     stdio: "inherit",
     windowsHide: true,
     env: { ...process.env, RELAY_BOOTSTRAP_ACTIVATED: "1" },
@@ -684,12 +704,32 @@ async function activateRuntime(layout, runtime, version, {
     rollback(message);
     fail(message);
   }
-  const health = await waitForRuntimeHealth(runtime, {
-    healthCheck,
-    attempts: healthAttempts,
-    intervalMs: healthIntervalMs,
-    ...(sleep ? { sleep } : {}),
-  });
+  let health = null;
+  if (platform === "darwin") {
+    const activated = await activateMacServices(runtime, {
+      homeDir,
+      platform,
+      run: spawnImpl,
+      healthCheck,
+      activationDeadlineMs,
+      now,
+      ...(sleep ? { sleep } : {}),
+    });
+    if (!activated?.ok) {
+      const detail = activated?.detail ? ` (${activated.detail})` : "";
+      const message = `Relay runtime activation could not start the exact registered macOS services${detail}.`;
+      rollback(message);
+      fail(message);
+    }
+    health = activated.health;
+  } else {
+    health = await waitForRuntimeHealth(runtime, {
+      healthCheck,
+      attempts: healthAttempts,
+      intervalMs: healthIntervalMs,
+      ...(sleep ? { sleep } : {}),
+    });
+  }
   if (!health?.ok) {
     const missing = [health?.daemon ? "" : "daemon", health?.pill ? "" : "pill"].filter(Boolean).join(" and ");
     const message = `Relay runtime activation failed exact-root health${missing ? ` (${missing} did not start)` : ""}.`;

package/bootstrap/runtime-executables.cjs

@@ -0,0 +1,88 @@
+"use strict";
+
+const fs = require("node:fs");
+const path = require("node:path");
+
+const MAC_HELPER_EXECUTABLES = [
+  ["Electron Helper.app", "Electron Helper"],
+  ["Electron Helper (GPU).app", "Electron Helper (GPU)"],
+  ["Electron Helper (Plugin).app", "Electron Helper (Plugin)"],
+  ["Electron Helper (Renderer).app", "Electron Helper (Renderer)"],
+];
+
+function platformName(value = process.platform) {
+  return String(value).split("-")[0];
+}
+
+function pathsFor(platform) {
+  return platformName(platform) === "win32" ? path.win32 : path.posix;
+}
+
+function runtimeExecutableInventory(packageRoot, {
+  platform = process.platform,
+  existsSync = fs.existsSync,
+} = {}) {
+  const name = platformName(platform);
+  const api = pathsFor(name);
+  const roots = [api.join(packageRoot, "node_modules", "electron"), api.join(api.dirname(packageRoot), "electron")];
+  const mainRelative = name === "win32"
+    ? api.join("dist", "electron.exe")
+    : name === "darwin"
+      ? api.join("dist", "Electron.app", "Contents", "MacOS", "Electron")
+      : api.join("dist", "electron");
+  const electronRoot = roots.find((root) => {
+    try { return existsSync(api.join(root, mainRelative)); } catch { return false; }
+  });
+  if (!electronRoot) return { ok: false, reason: "candidate-electron-missing", paths: [] };
+
+  const entries = [{ role: "electron", path: api.join(electronRoot, mainRelative) }];
+  if (name === "darwin") {
+    const frameworks = api.join(electronRoot, "dist", "Electron.app", "Contents", "Frameworks");
+    for (const [app, executable] of MAC_HELPER_EXECUTABLES) {
+      entries.push({ role: `helper:${executable}`, path: api.join(frameworks, app, "Contents", "MacOS", executable) });
+    }
+    entries.push({
+      role: "helper:chrome_crashpad_handler",
+      path: api.join(
+        frameworks,
+        "Electron Framework.framework",
+        "Versions",
+        "A",
+        "Helpers",
+        "chrome_crashpad_handler",
+      ),
+    });
+  }
+  return { ok: true, electronRoot, electronPath: entries[0].path, paths: entries };
+}
+
+function verifyRuntimeExecutables(packageRoot, {
+  platform = process.platform,
+  existsSync = fs.existsSync,
+  statSync = fs.statSync,
+  accessSync = fs.accessSync,
+} = {}) {
+  const name = platformName(platform);
+  const inventory = runtimeExecutableInventory(packageRoot, { platform: name, existsSync });
+  if (!inventory.ok) return inventory;
+  for (const entry of inventory.paths) {
+    try {
+      if (!existsSync(entry.path)) return { ok: false, reason: "candidate-executable-missing", detail: entry.role };
+      if (!statSync(entry.path).isFile()) return { ok: false, reason: "candidate-executable-invalid", detail: entry.role };
+      if (name !== "win32") accessSync(entry.path, fs.constants.X_OK);
+    } catch (error) {
+      return {
+        ok: false,
+        reason: error?.code === "ENOENT" ? "candidate-executable-missing" : "candidate-not-executable",
+        detail: entry.role,
+      };
+    }
+  }
+  return { ...inventory, ok: true };
+}
+
+module.exports = {
+  MAC_HELPER_EXECUTABLES,
+  runtimeExecutableInventory,
+  verifyRuntimeExecutables,
+};

package/bootstrap/runtime-health.cjs

@@ -1,8 +1,12 @@
 "use strict";
 
 const path = require("node:path");
+const os = require("node:os");
 const { spawnSync } = require("node:child_process");
 
+const DAEMON_LABEL = "work.relay.companion";
+const PILL_LABEL = "work.relay.companion.pill";
+
 // A local checkout may run beside Relay without invalidating the installed
 // runtime. Only installed relay-companion trees count as production services.
 const SERVICE_TREE_RE = /node_modules[\\/]relay-companion[\\/]/i;
@@ -44,4 +48,148 @@ function exactRuntimeHealth(target, {
   return { ok: daemon && pill && !oldDaemon && !oldPill, daemon, pill, oldDaemon, oldPill, packageRoot: target.packageRoot };
 }
 
-module.exports = { exactRuntimeHealth, runtimeProcessCommands };
+function installedServiceProcessRows(target, {
+  run = defaultRun,
+  includeTarget = false,
+  processId = process.pid,
+} = {}) {
+  const result = run("/bin/ps", ["-axo", "pid=,command="]);
+  if (!commandOk(result)) {
+    return {
+      ok: false,
+      rows: [],
+      reason: "service-process-query-failed",
+      detail: result?.error?.message || String(result?.stderr || result?.stdout || "").trim(),
+    };
+  }
+  const targetNeedle = String(target?.packageRoot || "").replaceAll("\\", "/");
+  const rows = [];
+  for (const line of String(result.stdout || "").split("\n")) {
+    const match = line.match(/^\s*(\d+)\s+(.*)$/);
+    if (!match) continue;
+    const pid = Number(match[1]);
+    const command = match[2];
+    // This is the safety boundary: only an immutable/global production install
+    // has node_modules/relay-companion in its command. A checkout's daemon or
+    // Electron pill is deliberately invisible and must never be terminated.
+    if (!SERVICE_TREE_RE.test(command)) continue;
+    const isDaemon = /(?:^|[\\/])relay\.js(?:"|'|\s).*\bdaemon\b/i.test(command);
+    const isPill = /(?:^|[\\/])overlay[\\/]main\.cjs(?:"|'|\s|$)/i.test(command);
+    if (!isDaemon && !isPill) continue;
+    if (!includeTarget && targetNeedle && command.replaceAll("\\", "/").includes(targetNeedle)) continue;
+    if (!Number.isInteger(pid) || pid <= 0 || pid === processId) continue;
+    rows.push({ pid, command });
+  }
+  return { ok: true, rows };
+}
+
+async function terminateInstalledServiceProcesses(target, {
+  run = defaultRun,
+  sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms)),
+  graceMs = 2000,
+  includeTarget = false,
+  processId = process.pid,
+} = {}) {
+  const first = installedServiceProcessRows(target, { run, includeTarget, processId });
+  if (!first.ok) return first;
+  if (!first.rows.length) return { ok: true, terminated: [] };
+  for (const row of first.rows) run("/bin/kill", ["-TERM", String(row.pid)]);
+  await sleep(graceMs);
+  const afterTerm = installedServiceProcessRows(target, { run, includeTarget, processId });
+  if (!afterTerm.ok) return afterTerm;
+  const originalPids = new Set(first.rows.map((row) => row.pid));
+  const survivors = afterTerm.rows.filter((row) => originalPids.has(row.pid));
+  for (const row of survivors) run("/bin/kill", ["-KILL", String(row.pid)]);
+  if (survivors.length) await sleep(500);
+  const afterKill = installedServiceProcessRows(target, { run, includeTarget, processId });
+  if (!afterKill.ok) return afterKill;
+  const remaining = afterKill.rows.filter((row) => originalPids.has(row.pid));
+  if (remaining.length) {
+    return { ok: false, reason: "service-process-stop-failed", detail: remaining.map((row) => row.pid).join(",") };
+  }
+  return { ok: true, terminated: first.rows.map((row) => row.pid) };
+}
+
+/**
+ * Restart Relay's two macOS jobs from the registrations already written by the
+ * caller, then prove that both processes belong to the requested package root.
+ * Registration remains owned by setup/repair; this helper owns only the narrow
+ * launchd handoff and never edits a plist, account file, or installed binary.
+ */
+async function activateMacRuntimeServices(target, {
+  homeDir = os.homedir(),
+  platform = process.platform,
+  run = defaultRun,
+  sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms)),
+  domainPollMs = 250,
+  bootstrapDelayMs = 500,
+  healthPollMs = 500,
+  activationDeadlineMs = 90_000,
+  now = Date.now,
+  processId = process.pid,
+  healthCheck = exactRuntimeHealth,
+} = {}) {
+  if (platform !== "darwin") return { ok: false, reason: "activation-platform-unsupported" };
+  if (!target?.packageRoot || !target?.bin) return { ok: false, reason: "activation-target-invalid" };
+  const domain = `gui/${typeof process.getuid === "function" ? process.getuid() : 0}`;
+  const agents = path.posix.join(String(homeDir || ""), "Library", "LaunchAgents");
+  const labels = [PILL_LABEL, DAEMON_LABEL];
+  const deadline = now() + Math.max(1, activationDeadlineMs);
+  for (const label of labels) run("/bin/launchctl", ["bootout", `${domain}/${label}`]);
+
+  // launchctl bootout is asynchronous. Keep quiescence, bootstrap, and liveness
+  // under one deadline so a racing EIO cannot create an unbounded retry loop.
+  while (now() <= deadline) {
+    const labelsPresent = labels.filter((label) => commandOk(run("/bin/launchctl", ["print", `${domain}/${label}`])));
+    if (labelsPresent.length) {
+      for (const label of labelsPresent) run("/bin/launchctl", ["bootout", `${domain}/${label}`]);
+      await sleep(domainPollMs);
+      continue;
+    }
+
+    const stopped = await terminateInstalledServiceProcesses(target, {
+      run,
+      sleep,
+      includeTarget: true,
+      processId,
+    });
+    if (!stopped.ok) return stopped;
+
+    let bootstrapFailure = null;
+    for (const label of labels) {
+      const started = run("/bin/launchctl", ["bootstrap", domain, path.posix.join(agents, `${label}.plist`)]);
+      if (!commandOk(started)) {
+        bootstrapFailure = { label, result: started };
+        break;
+      }
+    }
+    if (bootstrapFailure) {
+      for (const label of labels) run("/bin/launchctl", ["bootout", `${domain}/${label}`]);
+      const detail = String(bootstrapFailure.result?.stderr || bootstrapFailure.result?.stdout || "");
+      if (!/(?:Bootstrap failed:\s*5|Input\/output error|I\/O error)/i.test(detail)) {
+        return { ok: false, reason: "service-bootstrap-failed", detail: `${bootstrapFailure.label}: ${detail}` };
+      }
+      await sleep(bootstrapDelayMs);
+      continue;
+    }
+
+    while (now() <= deadline) {
+      const health = await healthCheck(target, { platform, run });
+      if (health?.ok) return { ok: true, health };
+      if (health?.oldDaemon || health?.oldPill) {
+        for (const label of labels) run("/bin/launchctl", ["bootout", `${domain}/${label}`]);
+        break;
+      }
+      await sleep(healthPollMs);
+    }
+  }
+  return { ok: false, reason: "activation-deadline-exceeded", detail: target.packageRoot };
+}
+
+module.exports = {
+  activateMacRuntimeServices,
+  exactRuntimeHealth,
+  installedServiceProcessRows,
+  runtimeProcessCommands,
+  terminateInstalledServiceProcesses,
+};

package/npm-shrinkwrap.json

@@ -1,12 +1,12 @@
 {
   "name": "relay-companion",
-  "version": "0.1.407",
+  "version": "0.1.409",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "relay-companion",
-      "version": "0.1.407",
+      "version": "0.1.409",
       "license": "MIT",
       "dependencies": {
         "@anthropic-ai/claude-agent-sdk": "0.3.195",