vibedate 0.4.0 → 0.5.0

package/dist/cli.js

@@ -1,15 +1,18 @@
 #!/usr/bin/env node
 import {
   runMcp
-} from "./chunk-ZB56ZBAR.js";
+} from "./chunk-I5U3O4RH.js";
 import {
   CANDIDATES,
+  DEFAULT_HANDLE,
   LIVE_NOTICE,
+  MAX_HANDLE_LEN,
   TOPIC_PREFIX,
   addBlock,
   allLeagueNames,
   canShareLive,
   connectProfile,
+  defaultStateDir,
   grantLiveConsent,
   isBlocked,
   league,
@@ -17,6 +20,7 @@ import {
   leagueTopic,
   leaguesWithin,
   loadBlocklist,
+  loadHandle,
   loadOrCreateIdentity,
   loadPeers,
   loadProfile,
@@ -27,16 +31,356 @@ import {
   removeBlock,
   resolveHandle,
   sameHandle,
+  sanitizePeerText,
   saveHandle,
   signHelloClaims,
   startDiscovery
-} from "./chunk-43IYNWES.js";
+} from "./chunk-KKWP4DLY.js";
 
 // src/cli.ts
 import readline from "readline";
 import "url";
 import process2 from "process";
 
+// src/handlegen.ts
+import { randomBytes } from "crypto";
+var FIRST = [
+  "segfault",
+  "yak",
+  "vibe",
+  "null",
+  "async",
+  "await",
+  "heap",
+  "stack",
+  "sudo",
+  "regex",
+  "token",
+  "prompt",
+  "context",
+  "merge",
+  "rebase",
+  "hotfix",
+  "flaky",
+  "cursed",
+  "based",
+  "quantum",
+  "turbo",
+  "neural",
+  "agentic",
+  "kernel",
+  "docker",
+  "kube",
+  "lambda",
+  "pointer",
+  "buffer",
+  "packet",
+  "syscall",
+  "runtime",
+  "monad",
+  "borrow",
+  "cache",
+  "deadlock",
+  "localhost",
+  "darkmode",
+  "wasm",
+  "diff"
+];
+var SECOND = [
+  "sommelier",
+  "shaver",
+  "goblin",
+  "nomad",
+  "gremlin",
+  "wizard",
+  "bard",
+  "pirate",
+  "ninja",
+  "monk",
+  "prophet",
+  "oracle",
+  "smith",
+  "farmer",
+  "whisperer",
+  "tamer",
+  "connoisseur",
+  "maximalist",
+  "enjoyer",
+  "dealer",
+  "herder",
+  "wrangler",
+  "juggler",
+  "mechanic",
+  "surgeon",
+  "detective",
+  "librarian",
+  "alchemist",
+  "overlord",
+  "apprentice",
+  "sensei",
+  "chef",
+  "dj",
+  "ranger",
+  "paladin",
+  "barbarian",
+  "summoner",
+  "cartographer",
+  "archivist",
+  "plumber"
+];
+var SUFFIX = [
+  "prime",
+  "9000",
+  "3000",
+  "max",
+  "ultra",
+  "xl",
+  "mk2",
+  "777",
+  "404",
+  "1337",
+  "2077",
+  "xd"
+];
+function cryptoRand() {
+  return randomBytes(4).readUInt32BE(0) / 2 ** 32;
+}
+function pick(list, rand) {
+  return list[Math.min(list.length - 1, Math.floor(rand() * list.length))];
+}
+function generateHandle(rand = cryptoRand) {
+  const first = pick(FIRST, rand);
+  const second = pick(SECOND, rand);
+  let body = `${first}_${second}`;
+  if (rand() < 0.5) {
+    const withSuffix = `${body}_${pick(SUFFIX, rand)}`;
+    if (withSuffix.length + 1 <= MAX_HANDLE_LEN) body = withSuffix;
+  }
+  const canonical = normalizeHandle(body);
+  if (canonical === null) throw new Error(`handle generator produced an invalid handle: ${body}`);
+  return canonical;
+}
+function ensureHandle(dir = defaultStateDir()) {
+  const env = process.env["VIBEDATING_HANDLE"];
+  if (env !== void 0 && env.trim() !== "") {
+    const canonical = normalizeHandle(env);
+    if (canonical !== null) return { handle: canonical, generated: false };
+  }
+  const persisted = loadHandle(dir);
+  if (persisted !== DEFAULT_HANDLE) return { handle: persisted, generated: false };
+  const generated = generateHandle();
+  return { handle: saveHandle(generated, dir), generated: true };
+}
+
+// src/daemon.ts
+import { spawn, spawnSync } from "child_process";
+import { mkdirSync, openSync, readFileSync, rmSync, writeFileSync } from "fs";
+import os from "os";
+import path from "path";
+function daemonStatePath(dir) {
+  return path.join(dir, "daemon.json");
+}
+function daemonLogPath(dir) {
+  return path.join(dir, "daemon.log");
+}
+function readDaemonState(dir = defaultStateDir()) {
+  try {
+    const raw = readFileSync(daemonStatePath(dir), "utf8");
+    const data = JSON.parse(raw);
+    if (typeof data["pid"] !== "number" || !Number.isInteger(data["pid"]) || data["pid"] <= 0 || typeof data["startedAt"] !== "string" || typeof data["any"] !== "boolean" || typeof data["version"] !== "string") {
+      return null;
+    }
+    return { pid: data["pid"], startedAt: data["startedAt"], any: data["any"], version: data["version"] };
+  } catch {
+    return null;
+  }
+}
+function writeDaemonState(dir, state) {
+  mkdirSync(dir, { recursive: true });
+  writeFileSync(daemonStatePath(dir), JSON.stringify(state, null, 2) + "\n", "utf8");
+}
+function removeDaemonState(dir = defaultStateDir()) {
+  try {
+    rmSync(daemonStatePath(dir), { force: true });
+  } catch {
+  }
+}
+function isPidAlive(pid, kill = process.kill) {
+  try {
+    kill(pid, 0);
+    return true;
+  } catch (err) {
+    return err.code === "EPERM";
+  }
+}
+function daemonStatus(dir = defaultStateDir(), alive = isPidAlive) {
+  const state = readDaemonState(dir);
+  if (state === null) return { running: false, state: null };
+  if (alive(state.pid)) return { running: true, state };
+  removeDaemonState(dir);
+  return { running: false, state: null };
+}
+function defaultSpawn(execPath, scriptPath, args, logPath) {
+  mkdirSync(path.dirname(logPath), { recursive: true });
+  const fd = openSync(logPath, "a");
+  const child = spawn(execPath, [scriptPath, ...args], {
+    detached: true,
+    stdio: ["ignore", fd, fd]
+  });
+  child.unref();
+  if (child.pid === void 0) throw new Error("could not spawn daemon child process");
+  return child.pid;
+}
+function startDaemon(opts) {
+  const dir = opts.dir ?? defaultStateDir();
+  const status = daemonStatus(dir, opts.alive);
+  if (status.running && status.state !== null) {
+    return { started: false, reason: `already running (pid ${status.state.pid})` };
+  }
+  const execPath = opts.execPath ?? process.execPath;
+  const scriptPath = opts.scriptPath ?? process.argv[1];
+  if (scriptPath === void 0) return { started: false, reason: "cannot locate the CLI entry point" };
+  const args = ["daemon", "run", ...opts.any ? ["--any"] : []];
+  const spawnProcess = opts.spawnProcess ?? ((a, logPath) => defaultSpawn(execPath, scriptPath, [...a], logPath));
+  const pid = spawnProcess(args, daemonLogPath(dir));
+  writeDaemonState(dir, { pid, startedAt: (/* @__PURE__ */ new Date()).toISOString(), any: opts.any, version: opts.version });
+  return { started: true, pid };
+}
+async function stopDaemon(opts = {}) {
+  const dir = opts.dir ?? defaultStateDir();
+  const kill = opts.kill ?? process.kill;
+  const alive = opts.alive ?? ((pid) => isPidAlive(pid, kill));
+  const state = readDaemonState(dir);
+  if (state === null) return { stopped: false, reason: "not running" };
+  if (!alive(state.pid)) {
+    removeDaemonState(dir);
+    return { stopped: false, reason: "not running (cleaned stale pidfile)" };
+  }
+  try {
+    kill(state.pid, "SIGTERM");
+  } catch {
+  }
+  const deadline = Date.now() + (opts.waitMs ?? 2e3);
+  while (Date.now() < deadline && alive(state.pid)) {
+    await new Promise((r) => setTimeout(r, 50));
+  }
+  removeDaemonState(dir);
+  return { stopped: true, pid: state.pid };
+}
+var DAEMON_SERVICE_LABEL = "ai.vibedating.daemon";
+var SYSTEMD_UNIT_NAME = "vibedating.service";
+function daemonServicePath(platform = process.platform, homeDir = os.homedir()) {
+  if (platform === "darwin") {
+    return path.join(homeDir, "Library", "LaunchAgents", `${DAEMON_SERVICE_LABEL}.plist`);
+  }
+  if (platform === "linux") {
+    return path.join(homeDir, ".config", "systemd", "user", SYSTEMD_UNIT_NAME);
+  }
+  return null;
+}
+function serviceArgv(execPath, scriptPath, any) {
+  return [execPath, scriptPath, "daemon", "run", ...any ? ["--any"] : []];
+}
+function renderLaunchdPlist(opts) {
+  const args = serviceArgv(opts.execPath, opts.scriptPath, opts.any).map((a) => `    <string>${a}</string>`).join("\n");
+  return `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>Label</key>
+  <string>${DAEMON_SERVICE_LABEL}</string>
+  <key>ProgramArguments</key>
+  <array>
+${args}
+  </array>
+  <key>RunAtLoad</key>
+  <true/>
+  <key>KeepAlive</key>
+  <false/>
+  <key>StandardOutPath</key>
+  <string>${opts.logPath}</string>
+  <key>StandardErrorPath</key>
+  <string>${opts.logPath}</string>
+</dict>
+</plist>
+`;
+}
+function renderSystemdUnit(opts) {
+  const execStart = serviceArgv(opts.execPath, opts.scriptPath, opts.any).join(" ");
+  return `[Unit]
+Description=vibedating notify-only daemon (alerts on new matches; never opens chat/video)
+
+[Service]
+ExecStart=${execStart}
+Restart=on-failure
+RestartSec=10
+
+[Install]
+WantedBy=default.target
+`;
+}
+var defaultRun = (cmd, args) => spawnSync(cmd, args, { stdio: "inherit" }).status === 0;
+function installDaemonService(opts) {
+  const platform = opts.platform ?? process.platform;
+  const homeDir = opts.homeDir ?? os.homedir();
+  const run = opts.run ?? defaultRun;
+  const servicePath = daemonServicePath(platform, homeDir);
+  if (servicePath === null) {
+    return {
+      installed: false,
+      servicePath: null,
+      detail: `unsupported platform (${platform}) \u2014 run \`vibedate daemon start\` manually instead`
+    };
+  }
+  const execPath = opts.execPath ?? process.execPath;
+  const scriptPath = opts.scriptPath ?? process.argv[1];
+  if (scriptPath === void 0) {
+    return { installed: false, servicePath, detail: "cannot locate the CLI entry point" };
+  }
+  mkdirSync(path.dirname(servicePath), { recursive: true });
+  if (platform === "darwin") {
+    const logPath = daemonLogPath(opts.dir ?? defaultStateDir());
+    writeFileSync(servicePath, renderLaunchdPlist({ execPath, scriptPath, any: opts.any, logPath }), "utf8");
+    const uid = process.getuid?.() ?? 501;
+    run("launchctl", ["bootout", `gui/${uid}`, servicePath]);
+    if (!run("launchctl", ["bootstrap", `gui/${uid}`, servicePath])) {
+      return { installed: false, servicePath, detail: "launchctl bootstrap failed \u2014 service written but not loaded" };
+    }
+    return { installed: true, servicePath, detail: "launchd agent installed \u2014 the daemon starts on login" };
+  }
+  writeFileSync(servicePath, renderSystemdUnit({ execPath, scriptPath, any: opts.any }), "utf8");
+  run("systemctl", ["--user", "daemon-reload"]);
+  if (!run("systemctl", ["--user", "enable", "--now", SYSTEMD_UNIT_NAME])) {
+    return { installed: false, servicePath, detail: "systemctl enable failed \u2014 unit written but not started" };
+  }
+  return { installed: true, servicePath, detail: "systemd --user service installed \u2014 the daemon starts on login" };
+}
+function uninstallDaemonService(opts) {
+  const platform = opts.platform ?? process.platform;
+  const homeDir = opts.homeDir ?? os.homedir();
+  const run = opts.run ?? defaultRun;
+  const servicePath = daemonServicePath(platform, homeDir);
+  if (servicePath === null) {
+    return {
+      installed: false,
+      servicePath: null,
+      detail: `unsupported platform (${platform})`
+    };
+  }
+  if (platform === "darwin") {
+    const uid = process.getuid?.() ?? 501;
+    run("launchctl", ["bootout", `gui/${uid}`, servicePath]);
+  } else {
+    run("systemctl", ["--user", "disable", "--now", SYSTEMD_UNIT_NAME]);
+    run("systemctl", ["--user", "daemon-reload"]);
+  }
+  try {
+    rmSync(servicePath, { force: true });
+  } catch {
+  }
+  return { installed: false, servicePath, detail: "login service removed \u2014 the daemon no longer starts on login" };
+}
+
 // src/pairing.ts
 function createPairing() {
   const queue = [];
@@ -110,6 +454,7 @@ function createPairing() {
 
 // src/server.ts
 import http from "http";
+import { randomUUID } from "crypto";
 import { makeEvent, notify as vibeCoreNotify } from "@pooriaarab/vibe-core";
 
 // src/web-app-html.ts
@@ -545,6 +890,80 @@ var webAppHtml = `<!DOCTYPE html>
     background: var(--danger); color: #2a0a0c;
   }
   .video-modal .vhangup:hover{ filter: brightness(1.06); }
+  .live-panel .lp-legend{ font-size: .66rem; color: var(--muted-2); margin-top: 8px; line-height: 1.4; }
+  .incoming-call{
+    position: fixed; inset: 0; z-index: 65;
+    display: flex; align-items: center; justify-content: center;
+    background: rgba(12,7,15,.6); backdrop-filter: blur(6px); -webkit-backdrop-filter: blur(6px);
+    opacity: 0; pointer-events: none; transition: opacity var(--dur-med) ease;
+  }
+  .incoming-call.is-open{ opacity: 1; pointer-events: auto; }
+  .incoming-call .ic-card{
+    background: linear-gradient(165deg, var(--bg-card), var(--bg-card-2));
+    border: 1px solid var(--border-2); border-radius: 24px; box-shadow: var(--shadow-3);
+    padding: 30px 28px; max-width: 320px; text-align: center;
+    transform: scale(.85) translateY(10px); transition: transform var(--dur-med) var(--ease-bounce);
+  }
+  .incoming-call.is-open .ic-card{ transform: scale(1) translateY(0); }
+  .incoming-call h3{ margin: 0 0 6px; font-size: 1.15rem; font-weight: 800; word-break: break-all; }
+  .incoming-call p{ color: var(--muted); font-size: .85rem; margin: 0 0 18px; }
+  .incoming-call .ic-actions{ display: flex; gap: 10px; }
+
+  /* ---- live text chat (browser <-> PeerLink over /live/message) ---- */
+  .live-actions{ display: flex; gap: 6px; flex-shrink: 0; }
+  .live-row .cbtn{
+    border: 1px solid var(--border-2); border-radius: 9px; padding: 7px 12px;
+    font-weight: 700; font-size: .76rem; background: transparent; color: var(--muted);
+    transition: color var(--dur-fast) ease, border-color var(--dur-fast) ease, transform var(--dur-fast) var(--ease-out);
+    flex-shrink: 0;
+  }
+  .live-row .cbtn:hover{ color: var(--fg); border-color: var(--muted-2); }
+  .live-row .cbtn:active{ transform: scale(.95); }
+  .live-row .cbtn.has-unread{ color: var(--coral); border-color: var(--coral); }
+  .chat-panel{
+    position: fixed; right: 18px; bottom: 18px; z-index: 45;
+    width: min(320px, calc(100vw - 36px));
+    background: linear-gradient(180deg, var(--bg-card), var(--bg-card-2));
+    border: 1px solid var(--border-2); border-radius: 16px; box-shadow: var(--shadow-2);
+    display: none; flex-direction: column; overflow: hidden;
+  }
+  .chat-panel.is-open{ display: flex; animation: rise var(--dur-med) var(--ease-out); }
+  .chat-panel .cp-head{
+    display: flex; align-items: center; justify-content: space-between; gap: 10px;
+    padding: 11px 14px; border-bottom: 1px solid var(--border);
+  }
+  .chat-panel .cp-title{ font-size: .84rem; font-weight: 700; word-break: break-all; }
+  .chat-panel .cp-sub{ font-size: .68rem; color: var(--muted-2); margin-top: 2px; }
+  .chat-panel .cp-close{
+    border: 0; background: transparent; color: var(--muted-2);
+    font-size: 1.15rem; line-height: 1; padding: 4px; flex-shrink: 0;
+  }
+  .chat-panel .cp-close:hover{ color: var(--fg); }
+  .chat-panel .cp-msgs{
+    padding: 12px 14px; min-height: 120px; max-height: 260px; overflow-y: auto;
+    display: flex; flex-direction: column; gap: 7px;
+  }
+  .chat-panel .cp-empty{ font-size: .76rem; color: var(--muted-2); text-align: center; margin: auto; }
+  .cp-msg{
+    max-width: 85%; padding: 7px 11px; border-radius: 13px;
+    font-size: .82rem; line-height: 1.4; word-break: break-word; white-space: pre-wrap;
+  }
+  .cp-msg.them{ align-self: flex-start; background: rgba(248,239,232,.07); border: 1px solid var(--border); }
+  .cp-msg.you{ align-self: flex-end; background: rgba(255,122,104,.16); border: 1px solid rgba(255,122,104,.32); }
+  .cp-msg.sys{ align-self: center; background: transparent; border: 0; color: var(--muted-2); font-size: .72rem; padding: 2px 6px; }
+  .chat-panel .cp-inputrow{ display: flex; gap: 8px; padding: 10px; border-top: 1px solid var(--border); }
+  .chat-panel .cp-inputrow input{
+    flex: 1; border: 1px solid var(--border-2); border-radius: 10px; background: rgba(0,0,0,.22);
+    color: var(--fg); padding: 9px 11px; font: inherit; font-size: .82rem; outline: none; min-width: 0;
+  }
+  .chat-panel .cp-inputrow input:focus{ border-color: var(--coral); }
+  .chat-panel .cp-send{
+    border: 0; border-radius: 10px; padding: 9px 14px; font-weight: 700; font-size: .8rem;
+    background: linear-gradient(180deg, var(--coral), var(--coral-dim)); color: #2a1109;
+    transition: filter var(--dur-fast) ease, transform var(--dur-fast) var(--ease-out);
+  }
+  .chat-panel .cp-send:hover{ filter: brightness(1.06); }
+  .chat-panel .cp-send:active{ transform: scale(.95); }
 </style>
 </head>
 <body>
@@ -689,9 +1108,36 @@ var webAppHtml = `<!DOCTYPE html>
   </div>
 </div>
 
-<aside class="live-panel" id="livePanel" aria-label="Live same-league peers">
-  <div class="lp-title"><span class="lp-dot" aria-hidden="true"></span> Live same-league peers</div>
+<aside class="live-panel" id="livePanel" aria-label="Live peers">
+  <div class="lp-title"><span class="lp-dot" aria-hidden="true"></span> Live peers</div>
   <div id="liveRows"></div>
+  <div class="lp-legend">&#10003; usage verified &middot; &#128273; identity verified &mdash; call someone, or wait for a call</div>
+</aside>
+
+<div class="incoming-call" id="incomingCall" role="dialog" aria-modal="true" aria-label="Incoming call">
+  <div class="ic-card">
+    <h3 id="incomingCaller">@peer</h3>
+    <p>is calling you &mdash; video chat</p>
+    <div class="ic-actions">
+      <button class="btn btn-ghost" id="declineBtn" type="button">Decline</button>
+      <button class="btn btn-primary" id="acceptBtn" type="button">Accept</button>
+    </div>
+  </div>
+</div>
+
+<aside class="chat-panel" id="chatPanel" aria-label="Text chat">
+  <div class="cp-head">
+    <div>
+      <div class="cp-title" id="chatTitle">@peer</div>
+      <div class="cp-sub" id="chatSub">live over the P2P link &middot; text only</div>
+    </div>
+    <button class="cp-close" id="chatClose" type="button" aria-label="Close chat">&times;</button>
+  </div>
+  <div class="cp-msgs" id="chatMsgs"></div>
+  <div class="cp-inputrow">
+    <input id="chatInput" type="text" maxlength="4000" placeholder="message&hellip;" autocomplete="off">
+    <button class="cp-send" id="chatSend" type="button">Send</button>
+  </div>
 </aside>
 
 <div class="video-modal" id="videoModal" role="dialog" aria-modal="true" aria-label="Video call">
@@ -998,9 +1444,15 @@ var webAppHtml = `<!DOCTYPE html>
   var remoteVideo = document.getElementById("remoteVideo");
   var remoteLabel = document.getElementById("remoteLabel");
   var hangupBtn = document.getElementById("hangupBtn");
+  var incomingCallEl = document.getElementById("incomingCall");
+  var incomingCaller = document.getElementById("incomingCaller");
+  var acceptBtn = document.getElementById("acceptBtn");
+  var declineBtn = document.getElementById("declineBtn");
 
   // One in-flight call's state. remoteHandle === null means idle.
   var rtc = { pc: null, localStream: null, remoteHandle: null, role: null };
+  // An incoming offer awaiting the user's accept/decline (never auto-answered).
+  var pendingOffer = null;
   var knownPeers = [];
   var idleIdx = 0;
 
@@ -1117,7 +1569,8 @@ var webAppHtml = `<!DOCTYPE html>
   }
 
   // Idle listener: when not in a call, watch known peers round-robin so an
-  // incoming offer (the peer clicked THEIR Video button) is noticed and answered.
+  // incoming offer (the peer clicked THEIR Call button) is noticed. Offers are
+  // never auto-answered \u2014 the caller is named and the user accepts or declines.
   async function idleLoop(){
     while (true) {
       if (rtc.remoteHandle || knownPeers.length === 0) { await sleep(1000); continue; }
@@ -1129,7 +1582,12 @@ var webAppHtml = `<!DOCTYPE html>
           var data = await res.json();
           var f = data && data.frame;
           if (f && f.t === "rtc-offer" && !rtc.pc && !rtc.remoteHandle) {
-            await answerIncomingOffer(peer.handle, f.sdp);
+            // One prompt at a time: a re-offer from the SAME caller refreshes
+            // the stored sdp; an offer from someone else while a prompt is up
+            // is dropped (their call simply fails to connect).
+            if (pendingOffer && pendingOffer.handle !== peer.handle) continue;
+            pendingOffer = { handle: peer.handle, sdp: f.sdp };
+            showIncomingPrompt(peer.handle);
           }
         }
       } catch(e){ /* abort/timeout \u2014 loop to next peer */ }
@@ -1137,6 +1595,22 @@ var webAppHtml = `<!DOCTYPE html>
   }
   idleLoop();
 
+  function showIncomingPrompt(handle){
+    incomingCaller.textContent = handle;
+    incomingCallEl.classList.add("is-open");
+  }
+  function clearIncomingPrompt(){
+    pendingOffer = null;
+    incomingCallEl.classList.remove("is-open");
+  }
+  acceptBtn.addEventListener("click", function(){
+    var p = pendingOffer;
+    clearIncomingPrompt();
+    if (!p) return;
+    answerIncomingOffer(p.handle, p.sdp).catch(function(){ hangup(); });
+  });
+  declineBtn.addEventListener("click", clearIncomingPrompt);
+
   function hangup(){
     try { if (rtc.pc) rtc.pc.close(); } catch(e){}
     rtc.pc = null;
@@ -1152,7 +1626,171 @@ var webAppHtml = `<!DOCTYPE html>
   }
   hangupBtn.addEventListener("click", hangup);
 
-  // Render the live-peers panel with a Video button each.
+  /* ---- Live text chat: msg frames over the same PeerLinks, via /live/message ----
+   * One long-poll loop per connected peer surfaces incoming texts immediately,
+   * no matter which conversation is open. Outbound texts POST {handle, text};
+   * the server re-validates through the frame allowlist and mints id/at. */
+  var chatPanel = document.getElementById("chatPanel");
+  var chatTitle = document.getElementById("chatTitle");
+  var chatSub = document.getElementById("chatSub");
+  var chatMsgs = document.getElementById("chatMsgs");
+  var chatInput = document.getElementById("chatInput");
+  var chatSend = document.getElementById("chatSend");
+  var chatClose = document.getElementById("chatClose");
+
+  var chatWith = null;      // handle of the open conversation (null = closed)
+  var conversations = {};   // handle -> [{from:"you"|"them"|"sys", text}]
+  var unread = {};          // handle -> count of unseen incoming messages
+  var chatLoops = {};       // handle -> true while its poll loop is running
+  var MAX_CHAT_KEPT = 200;  // per-conversation local cap (mirrors the server)
+
+  function fetchMessage(handle, timeoutMs){
+    var ctrl = new AbortController();
+    var t = setTimeout(function(){ ctrl.abort(); }, timeoutMs);
+    return fetch("/live/message?handle=" + encodeURIComponent(handle), { signal: ctrl.signal })
+      .then(function(r){ clearTimeout(t); return r; })
+      .catch(function(e){ clearTimeout(t); throw e; });
+  }
+
+  function postChat(handle, text){
+    return fetch("/live/message", {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify({ handle: handle, text: text })
+    });
+  }
+
+  function peerKnown(handle){
+    for (var i = 0; i < knownPeers.length; i++){ if (knownPeers[i].handle === handle) return true; }
+    return false;
+  }
+
+  function pushChat(handle, entry){
+    var conv = conversations[handle] || (conversations[handle] = []);
+    conv.push(entry);
+    if (conv.length > MAX_CHAT_KEPT) conv.splice(0, conv.length - MAX_CHAT_KEPT);
+  }
+
+  // One long-poll loop per connected peer: started when the peer is first
+  // seen, stopped when it vanishes (its mailbox on the server is gone).
+  function ensureChatLoop(handle){
+    if (chatLoops[handle]) return;
+    chatLoops[handle] = true;
+    (async function(){
+      while (peerKnown(handle)) {
+        var res;
+        try { res = await fetchMessage(handle, 30000); }
+        catch(e){ await sleep(1000); continue; }
+        if (!res || res.status !== 200) { await sleep(1000); continue; }
+        var data = await res.json();
+        var m = data && data.message;
+        if (!m) continue; // timed out empty
+        pushChat(handle, { from: "them", text: m.text });
+        if (chatWith === handle) {
+          renderChat();
+        } else {
+          unread[handle] = (unread[handle] || 0) + 1;
+          renderLiveRows(knownPeers);
+        }
+      }
+      delete chatLoops[handle];
+    })();
+  }
+
+  function renderChat(){
+    chatMsgs.innerHTML = "";
+    var conv = (chatWith && conversations[chatWith]) || [];
+    if (conv.length === 0) {
+      var empty = document.createElement("div");
+      empty.className = "cp-empty";
+      empty.textContent = "No messages yet \u2014 say hi.";
+      chatMsgs.appendChild(empty);
+      return;
+    }
+    conv.forEach(function(m){
+      var el = document.createElement("div");
+      el.className = "cp-msg " + (m.from === "you" ? "you" : m.from === "sys" ? "sys" : "them");
+      // textContent only \u2014 a peer's text is never parsed as HTML.
+      el.textContent = m.text;
+      chatMsgs.appendChild(el);
+    });
+    chatMsgs.scrollTop = chatMsgs.scrollHeight;
+  }
+
+  function openChat(handle){
+    chatWith = handle;
+    delete unread[handle];
+    chatTitle.textContent = handle;
+    chatSub.textContent = peerKnown(handle)
+      ? "live over the P2P link \xB7 text only"
+      : "peer offline \xB7 messages will not deliver";
+    chatPanel.classList.add("is-open");
+    renderChat();
+    renderLiveRows(knownPeers);
+    chatInput.focus();
+  }
+  chatClose.addEventListener("click", function(){
+    chatWith = null;
+    chatPanel.classList.remove("is-open");
+  });
+
+  function sendChat(){
+    var target = chatWith;
+    var text = chatInput.value.trim();
+    if (!target || text === "") return;
+    chatInput.value = "";
+    postChat(target, text).then(function(res){
+      // Honest failure \u2014 never show a message as sent when it wasn't.
+      pushChat(target, res && res.status === 200
+        ? { from: "you", text: text }
+        : { from: "sys", text: "(not delivered \u2014 peer offline?)" });
+      if (chatWith === target) renderChat();
+    }).catch(function(){
+      pushChat(target, { from: "sys", text: "(not delivered \u2014 server unreachable)" });
+      if (chatWith === target) renderChat();
+    });
+  }
+  chatSend.addEventListener("click", sendChat);
+  chatInput.addEventListener("keydown", function(e){ if (e.key === "Enter") sendChat(); });
+
+  // Render the live-peers rows: one per connected peer with its verification
+  // marks, a Chat button (opens the conversation), and a Call button that
+  // rings THAT peer specifically.
+  function renderLiveRows(peers){
+    liveRows.innerHTML = "";
+    peers.forEach(function(p){
+      var row = document.createElement("div");
+      row.className = "live-row";
+      var who = document.createElement("div");
+      // Marks from the peer's hello, shown only when present: \u2713 usage
+      // verified (real local logs), \u{1F511} identity-verified (signed hello).
+      var marks = (p.verified === true ? " \u2713" : "") + (p.identityVerified === true ? " \u{1F511}" : "");
+      var h = document.createElement("div"); h.className = "h"; h.textContent = p.handle + marks;
+      var s = document.createElement("div"); s.className = "s"; s.textContent = p.league + " \xB7 " + p.harness;
+      who.appendChild(h); who.appendChild(s);
+      var actions = document.createElement("div");
+      actions.className = "live-actions";
+      var chatBtn = document.createElement("button");
+      chatBtn.className = "cbtn" + (unread[p.handle] ? " has-unread" : "");
+      chatBtn.type = "button";
+      chatBtn.textContent = "Chat" + (unread[p.handle] ? " (" + unread[p.handle] + ")" : "");
+      chatBtn.addEventListener("click", function(){ openChat(p.handle); });
+      var btn = document.createElement("button");
+      btn.className = "vbtn"; btn.type = "button"; btn.textContent = "Call";
+      btn.addEventListener("click", function(){
+        if (rtc.remoteHandle || pendingOffer) return; // already in a call / prompt
+        btn.disabled = true;
+        // DIRECTED call: the rtc-offer is relayed only to this peer's handle.
+        startCallAsOfferer(p.handle).catch(function(){ hangup(); });
+      });
+      actions.appendChild(chatBtn);
+      actions.appendChild(btn);
+      row.appendChild(who);
+      row.appendChild(actions);
+      liveRows.appendChild(row);
+    });
+  }
+
   async function refreshPeers(){
     try {
       var res = await fetch("/api/live/peers");
@@ -1160,26 +1798,15 @@ var webAppHtml = `<!DOCTYPE html>
       var data = await res.json();
       var peers = (data && data.peers) || [];
       knownPeers = peers;
+      peers.forEach(function(p){ ensureChatLoop(p.handle); });
+      if (chatWith) {
+        chatSub.textContent = peerKnown(chatWith)
+          ? "live over the P2P link \xB7 text only"
+          : "peer offline \xB7 messages will not deliver";
+      }
       if (peers.length === 0) { livePanel.classList.remove("is-open"); return; }
       livePanel.classList.add("is-open");
-      liveRows.innerHTML = "";
-      peers.forEach(function(p){
-        var row = document.createElement("div");
-        row.className = "live-row";
-        var who = document.createElement("div");
-        var h = document.createElement("div"); h.className = "h"; h.textContent = p.handle;
-        var s = document.createElement("div"); s.className = "s"; s.textContent = p.league + " \xB7 " + p.harness;
-        who.appendChild(h); who.appendChild(s);
-        var btn = document.createElement("button");
-        btn.className = "vbtn"; btn.type = "button"; btn.textContent = "Video";
-        btn.addEventListener("click", function(){
-          if (rtc.remoteHandle) return; // already in a call
-          btn.disabled = true;
-          startCallAsOfferer(p.handle).catch(function(){ btn.disabled = false; });
-        });
-        row.appendChild(who); row.appendChild(btn);
-        liveRows.appendChild(row);
-      });
+      renderLiveRows(peers);
     } catch(e){}
   }
   refreshPeers();
@@ -1190,19 +1817,37 @@ var webAppHtml = `<!DOCTYPE html>
 </html>`;
 
 // src/server.ts
+var MAX_QUEUED_MESSAGES = 200;
 function createLiveBridge() {
   const boxes = /* @__PURE__ */ new Map();
   const bridge = {
     get peers() {
-      return [...boxes.values()].map((m) => m.link.hello);
+      return [...boxes.values()].map((m) => {
+        const h = m.link.hello;
+        return {
+          handle: h.handle,
+          league: h.league,
+          harness: h.harness,
+          ...h.verified !== void 0 ? { verified: h.verified } : {},
+          ...h.identityVerified !== void 0 ? { identityVerified: h.identityVerified } : {}
+        };
+      });
     },
     addLink(link) {
       const handle2 = link.hello.handle;
-      boxes.set(handle2, { link, incoming: [] });
+      boxes.set(handle2, { link, incoming: [], messages: [] });
       link.onSignal((f) => {
         const mb = boxes.get(handle2);
         if (mb) mb.incoming.push(f);
       });
+      link.onMessage((m) => {
+        const mb = boxes.get(handle2);
+        if (!mb) return;
+        mb.messages.push({ ...m, text: sanitizePeerText(m.text) });
+        if (mb.messages.length > MAX_QUEUED_MESSAGES) {
+          mb.messages.splice(0, mb.messages.length - MAX_QUEUED_MESSAGES);
+        }
+      });
       link.onClose(() => {
         const cur = boxes.get(handle2);
         if (cur && cur.link === link) boxes.delete(handle2);
@@ -1223,6 +1868,22 @@ function createLiveBridge() {
         if (cur.incoming.length > 0) return cur.incoming.shift() ?? null;
       }
       return null;
+    },
+    sendMessage(handle2, text) {
+      boxes.get(handle2)?.link.send(text);
+    },
+    async pollMessage(handle2, timeoutMs) {
+      const mb = boxes.get(handle2);
+      if (!mb) return null;
+      if (mb.messages.length > 0) return mb.messages.shift() ?? null;
+      const deadline = Date.now() + timeoutMs;
+      while (Date.now() < deadline) {
+        await new Promise((r) => setTimeout(r, 100));
+        const cur = boxes.get(handle2);
+        if (!cur) return null;
+        if (cur.messages.length > 0) return cur.messages.shift() ?? null;
+      }
+      return null;
     }
   };
   return bridge;
@@ -1396,11 +2057,62 @@ async function handle(req, res, opts) {
     sendJson(res, 200, { ok: true });
     return;
   }
+  if (req.method === "GET" && pathname === "/live/message") {
+    const live = opts.live;
+    if (!live) {
+      sendJson(res, 200, { message: null, reason: "live-not-attached" });
+      return;
+    }
+    const handle2 = url.searchParams.get("handle") ?? "";
+    if (handle2 === "") {
+      sendJson(res, 400, { error: "missing handle" });
+      return;
+    }
+    const message = await live.pollMessage(handle2, 25e3);
+    if (req.destroyed || res.writableEnded) return;
+    sendJson(res, 200, { message });
+    return;
+  }
+  if (req.method === "POST" && pathname === "/live/message") {
+    const live = opts.live;
+    if (!live) {
+      sendJson(res, 400, { error: "live-not-attached" });
+      return;
+    }
+    const body = await readBody(req);
+    let parsed = {};
+    try {
+      parsed = JSON.parse(body);
+    } catch {
+      sendJson(res, 400, { error: "invalid JSON body" });
+      return;
+    }
+    const handle2 = typeof parsed["handle"] === "string" ? parsed["handle"] : "";
+    if (handle2 === "") {
+      sendJson(res, 400, { error: "missing handle" });
+      return;
+    }
+    const text = parsed["text"];
+    if (typeof text !== "string") {
+      sendJson(res, 400, { error: "missing text" });
+      return;
+    }
+    const reParsed = parseFrame(
+      JSON.stringify({ t: "msg", id: randomUUID(), text, at: Date.now() })
+    );
+    if (reParsed === null || reParsed.t !== "msg") {
+      sendJson(res, 400, { error: "invalid message text" });
+      return;
+    }
+    live.sendMessage(handle2, reParsed.text);
+    sendJson(res, 200, { ok: true });
+    return;
+  }
   sendJson(res, 404, { error: "not found" });
 }
 
 // src/cli.ts
-var VERSION = "0.4.0";
+var VERSION = "0.5.0";
 function parsePort(raw) {
   const n = Number(raw);
   if (!Number.isInteger(n) || n < 1 || n > 65535) return void 0;
@@ -1414,7 +2126,8 @@ function parseArgs(argv) {
     dating: false,
     any: false,
     arg: void 0,
-    to: void 0
+    to: void 0,
+    keepAlive: false
   };
   for (let i = 0; i < argv.length; i++) {
     const a = argv[i];
@@ -1426,7 +2139,8 @@ function parseArgs(argv) {
         dating: false,
         any: false,
         arg: void 0,
-        to: void 0
+        to: void 0,
+        keepAlive: false
       };
     }
     if (a === "--help" || a === "-h") {
@@ -1437,13 +2151,18 @@ function parseArgs(argv) {
         dating: false,
         any: false,
         arg: void 0,
-        to: void 0
+        to: void 0,
+        keepAlive: false
       };
     }
     if (a === "--live") {
       out = { ...out, live: true };
       continue;
     }
+    if (a === "--keep-alive") {
+      out = { ...out, keepAlive: true };
+      continue;
+    }
     if (a === "--any") {
       out = { ...out, any: true };
       continue;
@@ -1479,7 +2198,7 @@ function parseArgs(argv) {
       continue;
     }
     if (a.startsWith("-")) continue;
-    const known = a === "connect" || a === "matches" || a === "discover" || a === "open" || a === "live" || a === "find" || a === "handle" || a === "block" || a === "unblock" || a === "blocklist" || a === "mcp" || a === "help" ? a : null;
+    const known = a === "connect" || a === "matches" || a === "discover" || a === "open" || a === "live" || a === "find" || a === "handle" || a === "block" || a === "unblock" || a === "blocklist" || a === "daemon" || a === "mcp" || a === "help" ? a : null;
     if (known !== null && out.command === null) {
       out = { ...out, command: known };
     } else if (out.arg === void 0) {
@@ -1499,6 +2218,17 @@ function formatTokens(n) {
   if (abs >= 1e3) return `${trim(n / 1e3)}k`;
   return String(n);
 }
+function formatAgo(iso, now = /* @__PURE__ */ new Date()) {
+  const t = Date.parse(iso);
+  if (Number.isNaN(t)) return "unknown";
+  const s = Math.max(0, Math.floor((now.getTime() - t) / 1e3));
+  if (s < 60) return "just now";
+  const m = Math.floor(s / 60);
+  if (m < 60) return `${m}m ago`;
+  const h = Math.floor(m / 60);
+  if (h < 24) return `${h}h ago`;
+  return `${Math.floor(h / 24)}d ago`;
+}
 function verificationText(snapshot) {
   if (snapshot.source === "real") {
     return `verified: real usage \u2014 ${formatTokens(snapshot.totalTokens)} tokens from ${snapshot.harness} logs`;
@@ -1545,7 +2275,9 @@ function idMark(peer) {
 var MARKS_LEGEND = "marks: \u2713 usage verified (real local logs) \xB7 ~ unverified (self-report/demo/legacy) \xB7 \u{1F511} identity-verified (signed hello)";
 async function cmdConnect() {
   const harness = process2.env["VIBEDATING_HARNESS"] ?? "claude-code";
-  const handle2 = resolveHandle();
+  const ensured = ensureHandle();
+  const handle2 = ensured.handle;
+  const firstConnect = loadProfile() === null;
   const snapshot = await readUsage(harness);
   const profile = connectProfile(snapshot, handle2);
   const identity = loadOrCreateIdentity();
@@ -1555,12 +2287,20 @@ async function cmdConnect() {
 `);
   process2.stdout.write(`  handle: ${profile.handle}  \xB7  harness: ${profile.harness}
 `);
+  if (ensured.generated) {
+    process2.stdout.write(`  assigned handle: ${profile.handle} \u2014 change it with: vibedate handle @name
+`);
+  }
   process2.stdout.write(`  verification: ${verificationText(snapshot)}
 `);
   process2.stdout.write(`  identity: ed25519 ${identity.publicKeyHex.slice(0, 12)}\u2026 \u2014 signs your hello (\u{1F511})
 `);
   process2.stdout.write("\n");
-  process2.stdout.write("  \u2022 raw usage stays local \xB7 only league shared\n\n");
+  process2.stdout.write("  \u2022 raw usage stays local \xB7 only league shared\n");
+  if (firstConnect) {
+    process2.stdout.write("  \u2022 optional: get notified of new matches on login \u2014 `vibedate daemon install` (undo: daemon uninstall)\n");
+  }
+  process2.stdout.write("\n");
   return 0;
 }
 async function cmdHandle(arg) {
@@ -1613,7 +2353,8 @@ async function cmdMatches(live) {
 
 `);
     for (const p of livePeers) {
-      process2.stdout.write(`  ${p.handle.padEnd(28)} ${p.league} \xB7 ${p.harness} ${usageMark(p)}${idMark(p)}
+      const lastMsg = p.lastMessageAt !== void 0 ? ` \xB7 last msg ${formatAgo(p.lastMessageAt)}` : "";
+      process2.stdout.write(`  ${p.handle.padEnd(28)} ${p.league} \xB7 ${p.harness} ${usageMark(p)}${idMark(p)}${lastMsg}
 `);
     }
     process2.stdout.write("\n");
@@ -1698,7 +2439,7 @@ async function cmdDiscover(live, any) {
   );
   return 0;
 }
-async function cmdOpen(port) {
+async function cmdOpen(port, any) {
   const profile = loadProfile();
   let live;
   let session;
@@ -1712,7 +2453,14 @@ async function cmdOpen(port) {
   ${LIVE_NOTICE}
 `);
     const hello = buildHello(profile);
-    void startDiscovery({ hello, isBlocked: blockedChecker(), onLink: (link) => live.addLink(link) }).then((s) => {
+    const { topics, acceptLeague } = discoveryScope(profile.league, any);
+    void startDiscovery({
+      hello,
+      topics,
+      acceptLeague,
+      isBlocked: blockedChecker(),
+      onLink: (link) => live.addLink(link)
+    }).then((s) => {
       session = s;
     }).catch(() => {
     });
@@ -1721,9 +2469,11 @@ async function cmdOpen(port) {
   vibedating local web app \u2192 ${started.url}
 `);
   if (live) {
-    process2.stdout.write("  \u2022 live A/V (video) available for connected same-league peers\n");
+    process2.stdout.write(
+      any ? "  \u2022 live video + chat available for connected peers (ANY league \u2014 --any)\n" : "  \u2022 live video + chat available for connected peers (your league + adjacent; --any = everyone)\n"
+    );
   } else {
-    process2.stdout.write("  \u2022 connect first (`vibedating connect`) to enable live video\n");
+    process2.stdout.write("  \u2022 connect first (`vibedating connect`) to enable live video + chat\n");
   }
   process2.stdout.write("  \u2022 raw usage stays local \xB7 only league shared\n");
   process2.stdout.write("  (Ctrl+C to stop)\n\n");
@@ -1736,7 +2486,10 @@ async function cmdOpen(port) {
   await new Promise((resolve) => started.server.close(() => resolve()));
   return 0;
 }
-async function cmdLive(dating, any, to) {
+function shouldKeepAlive(flag, stdinIsTTY) {
+  return flag || stdinIsTTY !== true;
+}
+async function cmdLive(dating, any, to, keepAlive) {
   const profile = loadProfile();
   if (!profile) {
     process2.stderr.write("Not connected yet. Run `vibedating connect` first.\n");
@@ -1771,11 +2524,11 @@ async function cmdLive(dating, any, to) {
     }
     const { qual } = peerDirection(profile.league, link.hello.league);
     process2.stdout.write(
-      `  \xB7 matched ${link.hello.handle} (${link.hello.league}${qual} \xB7 ${link.hello.harness}) ${usageMark(link.hello)}${idMark(link.hello)}
+      `  \xB7 matched ${sanitizePeerText(link.hello.handle)} (${link.hello.league}${qual} \xB7 ${link.hello.harness}) ${usageMark(link.hello)}${idMark(link.hello)}
 `
     );
     link.onMessage((m) => {
-      process2.stdout.write(`  <${link.hello.handle}> ${m.text}
+      process2.stdout.write(`  <${sanitizePeerText(link.hello.handle)}> ${sanitizePeerText(m.text)}
 `);
     });
   });
@@ -1789,14 +2542,14 @@ async function cmdLive(dating, any, to) {
       if (target !== null && !sameHandle(link.hello.handle, target)) {
         const { qual } = peerDirection(profile.league, link.hello.league);
         process2.stdout.write(
-          `  + ${link.hello.handle} (${link.hello.league}${qual}) ${usageMark(link.hello)}${idMark(link.hello)} \u2014 not your target
+          `  + ${sanitizePeerText(link.hello.handle)} (${link.hello.league}${qual}) ${usageMark(link.hello)}${idMark(link.hello)} \u2014 not your target
 `
         );
         link.close();
         return;
       }
       if (target !== null) {
-        process2.stdout.write(`  \u2605 found ${link.hello.handle} \u2014 auto-opening
+        process2.stdout.write(`  \u2605 found ${sanitizePeerText(link.hello.handle)} \u2014 auto-opening
 `);
       }
       pairing.add(link);
@@ -1814,9 +2567,13 @@ async function cmdLive(dating, any, to) {
   };
   process2.once("SIGINT", stop);
   process2.once("SIGTERM", stop);
+  let quitRequested = false;
   for await (const line of rl) {
     const text = line.trim();
-    if (text === "/quit") break;
+    if (text === "/quit") {
+      quitRequested = true;
+      break;
+    }
     if (text === "/next") {
       pairing.next();
       continue;
@@ -1837,6 +2594,13 @@ async function cmdLive(dating, any, to) {
       process2.stdout.write("  \xB7 no peer yet \u2014 waiting for a match\u2026\n");
     }
   }
+  if (!quitRequested && shouldKeepAlive(keepAlive, process2.stdin.isTTY)) {
+    process2.stdout.write("  stdin closed \u2014 staying in the swarm (Ctrl+C / SIGTERM to leave)\n");
+    await new Promise((resolve) => {
+      process2.once("SIGINT", () => resolve());
+      process2.once("SIGTERM", () => resolve());
+    });
+  }
   process2.removeListener("SIGINT", stop);
   process2.removeListener("SIGTERM", stop);
   const cur = pairing.current();
@@ -1974,20 +2738,131 @@ async function cmdBlocklist() {
 `);
   return 0;
 }
+async function cmdDaemonRun(any) {
+  const profile = loadProfile();
+  if (!profile) {
+    process2.stderr.write("Not connected yet. Run `vibedating connect` first.\n");
+    return 1;
+  }
+  if (!canShareLive()) grantLiveConsent();
+  const dir = defaultStateDir();
+  writeDaemonState(dir, { pid: process2.pid, startedAt: (/* @__PURE__ */ new Date()).toISOString(), any, version: VERSION });
+  const hello = buildHello(profile);
+  const { topics, acceptLeague } = discoveryScope(profile.league, any);
+  const session = await startDiscovery({
+    hello,
+    topics,
+    acceptLeague,
+    isBlocked: blockedChecker(),
+    onPeer: (peer, isNew) => {
+      process2.stdout.write(
+        `  [${(/* @__PURE__ */ new Date()).toISOString()}] ${isNew ? "NEW match" : "peer seen"}: ${sanitizePeerText(peer.handle)} (${peer.league} \xB7 ${peer.harness})
+`
+      );
+    }
+  });
+  process2.stdout.write(
+    `  vibedating daemon running (pid ${process2.pid}) \u2014 notify-only${any ? " \xB7 --any" : ""}
+`
+  );
+  await new Promise((resolve) => {
+    process2.once("SIGINT", () => resolve());
+    process2.once("SIGTERM", () => resolve());
+  });
+  await session.close();
+  removeDaemonState(dir);
+  process2.stdout.write("  daemon stopped\n");
+  return 0;
+}
+async function cmdDaemon(arg, any) {
+  switch (arg) {
+    case "start": {
+      if (loadProfile() === null) {
+        process2.stderr.write("Not connected yet. Run `vibedating connect` first.\n");
+        return 1;
+      }
+      const r = startDaemon({ any, version: VERSION });
+      if (!r.started) {
+        process2.stdout.write(`  ${r.reason}
+`);
+        return 0;
+      }
+      process2.stdout.write(`  daemon started (pid ${r.pid}) \u2014 notify-only: alerts on NEW matches, never opens chat/video
+`);
+      process2.stdout.write(`  logs: ~/.vibedating/daemon.log \xB7 stop: vibedate daemon stop
+`);
+      return 0;
+    }
+    case "stop": {
+      const r = await stopDaemon();
+      process2.stdout.write(
+        r.stopped ? `  daemon stopped (pid ${r.pid})
+` : `  ${r.reason}
+`
+      );
+      return 0;
+    }
+    case "status": {
+      const s = daemonStatus();
+      if (s.running && s.state !== null) {
+        process2.stdout.write(
+          `  daemon running (pid ${s.state.pid}) since ${s.state.startedAt}${s.state.any ? " \xB7 --any" : ""}
+`
+        );
+      } else {
+        process2.stdout.write("  daemon not running\n");
+      }
+      return 0;
+    }
+    case "run":
+      return cmdDaemonRun(any);
+    case "install": {
+      if (loadProfile() === null) {
+        process2.stderr.write("Not connected yet. Run `vibedating connect` first.\n");
+        return 1;
+      }
+      const r = installDaemonService({ any });
+      process2.stdout.write(`  ${r.detail}
+`);
+      if (r.servicePath !== null) process2.stdout.write(`  service: ${r.servicePath}
+`);
+      if (r.installed) process2.stdout.write("  undo anytime: vibedate daemon uninstall\n");
+      return r.installed ? 0 : 1;
+    }
+    case "uninstall": {
+      const r = uninstallDaemonService({});
+      process2.stdout.write(`  ${r.detail}
+`);
+      return 0;
+    }
+    default:
+      process2.stderr.write("usage: vibedating daemon [start|stop|status|install|uninstall] [--any]\n");
+      return 1;
+  }
+}
 var HELP = `vibedating ${VERSION} \u2014 dating by tokens (local-first)
 
 Usage:
   vibedating connect            Read your usage, compute + print your league
   vibedating matches [--live]   List candidates in your league (live peers if any)
   vibedating discover [--live] [--any]  Find live peers over the DHT (your league + adjacent; --any = everyone)
-  vibedating live [--dating] [--any] [--to @handle]  Live chat (your league + adjacent; --any = everyone; /next or --dating pick; --to targets one peer)
+  vibedating live [--dating] [--any] [--to @handle] [--keep-alive]  Live chat (your league
+                                + adjacent; --any = everyone; /next or --dating pick;
+                                --to targets one peer; --keep-alive survives stdin EOF \u2014
+                                automatic when stdin is not a TTY)
   vibedating find <@handle> [--any]  Search the DHT for one specific handle (\u2605 highlights a match)
   vibedating handle [@name]     Print or set your handle (persisted; a leading '@' is optional)
   vibedating block <@handle>    Block a handle \u2014 their hello is dropped (never recorded/paired)
   vibedating unblock <@handle>  Remove a handle from the blocklist
   vibedating blocklist          List blocked handles
-  vibedating open [--port N]    Serve the local web app (default: random port)
-                                + live A/V video with connected same-league peers
+  vibedating daemon [start|stop|status|install|uninstall] [--any]
+                                Manage the notify-only background daemon \u2014 alerts on
+                                NEW matches, never opens chat/video. install adds a
+                                login service (launchd on macOS, systemd on Linux);
+                                uninstall removes it.
+  vibedating open [--port N] [--any]  Serve the local web app (default: random port)
+                                + live video + chat with connected peers
+                                (your league + adjacent; --any = every league)
   vibedating mcp                Run the stdio MCP server (profile, matches)
   vibedating --version
   vibedating --help
@@ -2001,9 +2876,10 @@ Privacy:
   (real local logs) \xB7 ~ unverified \xB7 \u{1F511} identity-verified (signed hello).
 
 Matching:
-  discover/live match your league + adjacent (\xB11) tiers by default, so thin
-  leagues and cross-league friends still connect. --any matches every league.
-  find / live --to look for one specific handle instead of the first random peer.
+  discover/live/open match your league + adjacent (\xB11) tiers by default, so
+  thin leagues and cross-league friends still connect. --any matches every
+  league. find / live --to look for one specific handle instead of the first
+  random peer.
 
 Env:
   VIBEDATING_TOKENS=<n>   Self-report a token count (e.g. 23400000 or 12M)
@@ -2031,14 +2907,16 @@ async function main(argv) {
       return cmdUnblock(parsed.arg);
     case "blocklist":
       return cmdBlocklist();
+    case "daemon":
+      return cmdDaemon(parsed.arg, parsed.any);
     case "matches":
       return cmdMatches(parsed.live);
     case "discover":
       return cmdDiscover(parsed.live, parsed.any);
     case "open":
-      return cmdOpen(parsed.port);
+      return cmdOpen(parsed.port, parsed.any);
     case "live":
-      return cmdLive(parsed.dating, parsed.any, parsed.to);
+      return cmdLive(parsed.dating, parsed.any, parsed.to, parsed.keepAlive);
     case "find":
       return cmdFind(parsed.arg, parsed.any);
     case "mcp":
@@ -2069,5 +2947,7 @@ if (entryUrl !== void 0) {
   }
 }
 export {
-  parseArgs
+  formatAgo,
+  parseArgs,
+  shouldKeepAlive
 };