@plannotator/cline 0.0.0-stage → 0.28.51

package/dist/index.js

@@ -0,0 +1,1610 @@
+// index.ts
+import { readFileSync as readFileSync3 } from "node:fs";
+import { dirname, join as join4 } from "node:path";
+import { fileURLToPath } from "node:url";
+
+// inbox.ts
+import { existsSync as existsSync4 } from "node:fs";
+
+// ../../packages/shared/config.ts
+import { isAbsolute as isAbsolute2, join as join2, resolve as resolve2 } from "path";
+
+// ../../packages/shared/data-dir.ts
+import { existsSync } from "fs";
+import { homedir } from "os";
+import { isAbsolute, join, resolve } from "path";
+function getPlannotatorDataDir() {
+  const home = homedir();
+  const envDir = process.env.PLANNOTATOR_DATA_DIR?.trim();
+  if (envDir) {
+    if (envDir === "~")
+      return home;
+    if (envDir.startsWith("~/") || envDir.startsWith("~\\")) {
+      return join(home, envDir.slice(2));
+    }
+    return resolve(envDir);
+  }
+  return getDefaultPlannotatorDataDir(home);
+}
+var DATA_DIR_MARKERS = [
+  "history",
+  "sessions",
+  "drafts",
+  "inbox",
+  "claude-code-mod",
+  "install-flags.json"
+];
+function holdsPlannotatorData(dir) {
+  return DATA_DIR_MARKERS.some((entry) => existsSync(join(dir, entry)));
+}
+function xdgPlannotatorDataDir() {
+  const xdgDataHome = process.env.XDG_DATA_HOME?.trim();
+  return xdgDataHome && isAbsolute(xdgDataHome) ? join(xdgDataHome, "plannotator") : null;
+}
+function getDefaultPlannotatorDataDir(home = homedir()) {
+  const legacyDir = join(home, ".plannotator");
+  const xdgDir = xdgPlannotatorDataDir();
+  if (existsSync(legacyDir)) {
+    if (xdgDir && existsSync(xdgDir) && holdsPlannotatorData(xdgDir) && !holdsPlannotatorData(legacyDir)) {
+      return xdgDir;
+    }
+    return legacyDir;
+  }
+  return xdgDir ?? legacyDir;
+}
+
+// ../../packages/shared/config.ts
+import {
+  readFileSync,
+  writeFileSync,
+  mkdirSync,
+  existsSync as existsSync2,
+  openSync,
+  writeSync,
+  closeSync,
+  statSync,
+  unlinkSync,
+  renameSync,
+  realpathSync
+} from "fs";
+
+// ../../packages/core/favicon.ts
+var FAVICON_PNG_BASE64 = [
+  "iVBORw0KGgoAAAANSUhEUgAAAEAAAABACAYAAACqaXHeAAAYhklEQVR42u2be7hdZX3nP7/3XWvty7mfkxu5UUJuJAFFiVIU",
+  "QS2d4gUrTuIUSisdBkZQEerz1Gr1cNqq1YoOF9vn6eA4M0adSWxBvFC1ToowyCVcDEkgGELI/SQ5J+e6L+vy/uaPtfY+e+9z",
+  "DgSVTv/ofp717GSdtdf7/m7f3/WFV/HT34/RfryZ/qabsdqP2bwh/X6pZ17NPcqr9WLtx8gADuCZu/o6lqqsNLHrdcr4aC54",
+  "fuF/PHq88fnjd/UtbIuT5cZKu3PeyMl277lFVx450fquf5UMUBD6EdYi7ERZi8hGkhO39S5uN+ZPrdrf9YSFeEACseOkWv1h",
+  "VYLPuGSyI2+8T0hsLvY92jEKiRDBMJ7cPVGRP+/96JH9W/vxLl6LshMh/dZfB1N+JQaoImzByEaS1r+d/GLf29vz5hueb+dT",
+  "VeJYVUEB8Q1CwRKWNAL1goKIlh2J4gBVxfgWoWiIYxmMVC4v3nD4oZm0DOBXYYT8OlT8B7eRu7CtZ4VWbV+MOUniutrV/NA3",
+  "UogijQQ8JFtLFRBVcFawquBUEwQjSO0pVFVRYj9v/ShmuBTopZrEHeIzX5yMJL63s/eaoy8C6AasbJkuhFeNATXid/TTfuac",
+  "vo95Tq4EWe5ZIY7BKc4XMbFTZySVkjYuppqZjmh2Q0AQabYrAKeqvjUSo3g+YAEnxLErqTU/HI/4dN9HB3foZuxMmvhrZ0CN",
+  "+CO3zz+jj+QeP2fPoeJIElBwgpiMRsWk7xeROtGNDAABSXW+kQE1ZqW6AppxyKFONGWNEbGmKCSOiUqcbGz/yIn7fhmwlFds",
+  "87cgQ7297R1qHglydnVcSkJEPKi5K8lEqqIZgdKoAY2MyJ7XmTYm09bO+NBwS0l8X7zYUCoZ73Wd1x9+jn7klTDBvBLi991C",
+  "jlvQgpM/CYpmdVxyoYgE6XtkSm6qktKpdeKntFqa+K4t0pAGRtVhs64rLTwSvCjS2PNNMYiSLwDQi6+bsb9WDWi1r+qX5x4K",
+  "rCyIY0UQo41kKM1SbxClam1BbcDD5q1IE2N0CjvRFiBp0DYBZ4hOtJvFtfhC+zHcgsrMCnbqDKjZ1dBXepbknX2fh1xkYnmP",
+  "1BGsQcrarL6ZZbfEDFqnXKThdylapL/VmfRjGj4iSPY+UWNFYqOP4OvPQtx3Oj449M81zX0pJrwUA0Qzeyrd0fcxH/NJzzfd",
+  "OIgrrkm1Z9JnkWYbl7pMa5FTuvo0Jknd4KdvsmHRVmVQBC9nqAVbEfrtku9f1/2fDg6/FBNmZUDNt058qe+Otg7vQzrhSBxx",
+  "ptWWFkG1Aj2SInhq1NKKZtNNpkkdMnORVokzTZskw0UVQQUnqg4V8TqNjSr6+Gih+61zDuyenM0cZk1CZAvJxG1zr2pr8z4U",
+  "j7kodqgIXo34mgpKzZXNgNxTFGidOVojVGkEONK4pwEb0CaGtoYI2giNtS/FgHiI2mg0Cf28vL6tNPJ5GcCxZWZaZca4XuEX",
+  "txMsdXN25TzzG1GkmAZmaQNkTflszSAp25w0aWxqr5lTb9VvaQBEadmMSgswNuJFg1lJE7zWeK2qIslETlb2fHBw30xxwnSu",
+  "bMaIoHOinvU5a5bFkSLTnpMWvNYmOxWZDn6pSUjd9lv/KDLj7YyJDR6iLnRtWlnRpjsCog7n5Y3vR3rJbPROZ8DO9I05Y9fg",
+  "oWng2ajSDURktquzKVYW2k8FQJq5Qmlx7joNS7VBWVpX0FYQ0elr1xVNVMWx4hUFQtqPwUhQd+IiDSinrc66Oc+Zwd01gkMK",
+  "AQ1uoMWFNt3QZg2gBVObQiqdzWuKGCScrbAy7ebjC1PXV411X12jlOkOftZQTprSnBmLBzU+qs648VYTmuZydbrg6yZUA1Od",
+  "Ylsk7pAM4Fg4o5VND3pOfLn3rC7PbpZE1jqnmIY0dfbIRKcHatO8XYOvnCHzU5kZlWnykDqjX5BGQ6k7H1FjRfHkxEQiV3Xf",
+  "eORHrUAorYnO4Y723jk2/3iQs0ujinNGxJxKSYiXjjhncUD6sq8VfamYcFowMQ0bFFE/EIlhfDJw53Zde3wvt0wlTFPEbUk5",
+  "02NynwoKZmlUcpERMVrz4TpTJtcIVoLDkGBIsA2Xl35L7f8GpwaXPZ9eNr3UkOjU7x2WOLumnjVNVjlbiFS7bQSJQhd5AR25",
+  "qhkQSUt2zdlEFio+c1dfx7Ixed4zZo5TVbRB+hlouQboERSj6VYhAYkBN3XV4910J/V/N2mA1JP+ZpDVqf+rZgmnAc0u8VOG",
+  "YVAMU0GnIupSNylSL7z4BqrOjZZ7ojN6rh4dqdGclqxvSXczZ1JWelbmulgVwYBmHDeZHEMgzAhVwAeTZ1KLjLkuRrSb0aSL",
+  "Ee1kJOlg1HUxru1MuiJlClQ1R5Ug1RJN35uCl8NqghVHIBEBEXlKtEmJdjNJlxmnw0zQKeN0yyg95iSdMka7mcTXElAFdaSJ",
+  "gI/DJ8YDBSMOQSVO0MA33ePVwnIY3bZlIwZIUgasRehXY2Vh0RDjUEVFnBgCUwIJgSKDbgH7kyXsTZaxN1rKvmgxh5IFDCW9",
+  "jCQdlJI8kaaLp8QJ1oBn0m9rUkWoXVIXvqAKiSqJA+cgUUhcejlVVB2iCb7EFKRMh1eix46ywJ5gqX+YM7z9LPf2coa3j4Xm",
+  "MHkdBrFE2l43XTFgEhPQ32827BqAjGWws18ZENdzJ/vjcF5swDpRDcyYbE/Wc2/lnTxWeQ17q0sZSrqJyeFZQ1ugdBeU7rxj",
+  "cQG6itBVgI68oZgzFAIh8IWcJ/iewbNSJ9w0hH6aqb9LC6Q4B7FTwkipxko5dJSqMFkVxsqWkcmAkVInI5WF/LwsPFgSqrGA",
+  "xrTLOEv8I7yusJPLC9/hzd79xFpUa0QiNdXetsN7GRhw9PcbGEglz4C4df3bV1dk3l33dLz//LWyzcQmJ1+Y/Bh/O/KHhK7A",
+  "gk7H4i7Hoh5Y1Gs5rdujs82jveARWEklZARrTC3ayRKcKeysF3gUGnNCoTG+b/brIo35QlYlysKbMHaUqwnj5YThiZjBkYQD",
+  "Q44XTsCLIwbnHNf2fINPtX0Gn7I+7N7qNo59/cHT4t1XP/qZ81+gX40Ht3BR/9b8gbj77xe2xWsWyAGHjeSz4wN8cfg6fvO0",
+  "Ud7xOsPKhUXmd3l05oWJinJ0IoXDaphQVUtHZw7noFpVojDCudTVGmMwRk7RMWqTR3Xq6gRbawlyPrkAkgRGR8t41lLMp0JY",
+  "PDePFcFpqjFHhqrc++gotx28Bl8SPtX+p7Ik2SfzA71oOJ7/rYv6t775/lqYf07/IyvDaNHuIuPu23OukJOuVy49+i3OW1jh",
+  "xncv4LzFHp0+WFHECHtOJDxxKGZeX45vbvo+/7Dpbtaddw7nvHYNa9atYsmShRSLHmIgrEIYRs2VHpklimyJ9QsFH9+HKIKx",
+  "sTJ7n9/H9qd28eTjT3P0yFH+4q8+wW8sW0K1EmZRey1yV/KBIYyV275zlJ0ncvx4wfuIndErRv6HS9RovrN0+pN/ctZhAVj1",
+  "Z8+s8pLcM6Hmpd2OaZtMyOHqPG56dy9/8IYinbkUnKwRjk8oDx9IUFU8TxgbneCpJ3ewbdvTPP/cC1QqFdrbiqxcs4Izly1h",
+  "3TlrWLL0NJLEpX6nodCBzhwbaabuO3Y+x/PPPc/ze/bz3LN7SJKE3r5u1p29mvPe+FpWr16OMXam8gNJorQXLU+9UOLO+0Y4",
+  "vXiM4aRLq9ouHpWq9aPlTw+sPJh1bkNU8pKTiIorMu7a6S3GnD7Hp91PVc5aGCkrjxxMcKpYIySJ0tXdxW9feiGXvfdCDh6a",
+  "4Ibr/ow9T+5izzN7KLQVedfl/47rrr+S0mSCGKm7+KYicr0Gl2KDZy0nR8b4+n/fwjO7nocjx6Crnbdf9lt88tPXY71Us6qV",
+  "uG4irTGQsRDFjnldPh05x+HqAjyT4EsEDeGNaa3JepkvFmPwbbpha2GsAj/bn5A4xTNSr0vHccz4WIUTQ1Vu/fzfcN171/PG",
+  "i1+Hdcqys1bw+x/YQLWSIMZMF7rOlLul75w7t4vrbvgA689dweduvYE5i+bxk83f4yu3b6JaVibGyynx0pCsthRg0gZKRhcR",
+  "BldL1qSFAUEdo5tKCpnvnKzCQ/sTqklKfFMy6JTurjwPPPAkZ84J+MuPX8n1v/92EqfsfOwJHrj/UQpFLwVFmUJ1dPZ6n1Ml",
+  "lzP8r2/eww3vfxMfv/49/Nab1iJewD/+4CccOXKCfD6Happ1qk6V3IXpdas0Q5zKFUSmctW0jWUjASto0rSpKIGhEjx8IKEc",
+  "p8Q71WmFSevBE9u2E0YxAA9t2w3WIsby+GNPNRcu9OU7MJ61jI6E7Nj+LLlcnjhJ2PWLQ1DMM3lylB1PP0sul7o5bWqmzJZs",
+  "KTWaDQmoeg0MUPEwB2NNDoReD0ZjRRUjaRDys/0xE6HiZ5KXFgQThGoIpYlx7v7+o1y4cYC7Nt+P15ZHRTg2eIJqVTFipny/",
+  "zp6Tq6Yub2RklLBS4aN/uYnzL+9n+44XCIo5iB1HDg82F5pbaiKN5bKaaYsqRhMXen0k6M6E8Bj9asyGDVvMroF1E0vzB3/v",
+  "DG93ZUT7JFZb620hAlZkhpxLmhgtgIsTHnxoV5pdZTiRJMnL1uB1BhyIogTrWQYHT/L4tt14+SCz+RQjWnsnU0CqJCL4zuG7",
+  "JGOIo+o8HaXHnGl3jC/vOHbFroF1YT/gbV6zUQXhR31vGSnH8/37cu/gC6MfkYh5SK3QILO7b1XFWOjq7kLUkW8vEMUxIoIk",
+  "ju6eLnxfiEKlVlrQrDaojZ0kmao1Js7R1lYkn8tRLVXwC7mMkanL6+3tbmzfNICe4kQQhfVHjjLY3cFB20aCz+LgsNzccQe/",
+  "U/xxPvAHQ0nLH5jMDDhWXrSq4Im9vPA1d27wFEOVPGEUZ6CpM0qvMcRdtXp56n9rlSERNHGsXL0c61HHDpflocWcoT2fXoXA",
+  "pJvPaohxFNPT28HS0xej1TBbR1CnSCHHqtUriMJGc5R6nO1EWHf8BL3lChihUo05GRW4KP8Al+U2JYHn+cerp68AhbWIYW0q",
+  "UE/DkjqDcwU5K3iesQrsPx4SeIKbBbhEFGMMlXLMBW9+Pb1LFhJOlPADn7BcId/bxcVvu4BK2WHEkKiS9w1Jojy+Z4J7Hxvl",
+  "e9tGeHrfROqLPJNlfoq1wqXvfBsaRmls4PtEo2Oc89p1rFx9BpVKtR79iSoqEFnL2qFhFk1MUrIek4U8+45UqcTKKn8vjjZR",
+  "B3mpTk6B4M6UAZUg3hVGcWjw5NLcj7TLjrN1R4nYpb7UzQjiqeJFUUxPTwc3/vG1FNvaqAydxDOGD910DUuWzKdaDXFAwTfs",
+  "Plzhc3cP8YV/jPn7R0tsebTCX93nuPW7wxwYCsn7BhXD5GTIxW97I++66nKisUkqwyc5bdnp3HDj1VPpbWbzsUkLNWcfP8GS",
+  "8XEAhjuKHBafB3aVOS0Y4mL/n9VIIGEcTU76+gwAG7JcoNYHLH1p7ncLee9dVE/Gn5r8a+/OE1fyB+ur/O4F8yhV4owZM4yy",
+  "CDjnKBZz7HvxKM9u38UZq85k5crTKU1WUYS2vGH3wQpf+sEoRSb4SNd/5fxgG06En8YXccfQ1eQCj49d1sNpPQHl0OFZ8Hyf",
+  "J5/YwfDxYV7/xnPp6e6gWg0xJrX1yBjaooizj51gbqlMbISR9iLPLprHpgeOs2V7G5+ecxs3Fz4b0zbHq1TibxZuHLyy1vKX",
+  "eh9gAB26rfesTvUe8zUujLoCv3fym/JYaR0bXlPl0vV9FHOGKFbihMwstKEBojin5HIBQU4Iq5qpqaEtbxgaj/j8PcOUy1U2",
+  "z72as70HQdvTd9gJtlYv56rBO1gx13HTZXPJeUI5TDPKYjGHtVAux8RxjDEmJV6EheMTvObYiTRgay8w1NXODpvnO48M8d2d",
+  "BS7t/L98teOPNO8bicSMTPp6bvd/HnyxVhi1AAP3o2s3YNffWj5202/nn/at//4ik7w9/39kp76Ge188g937x8FFtAVCMQOu",
+  "nC/4nuBbwQp4VkATojBGcOQDS94X9h8v83c/Psme0XbumPsJ3uJ9n7IuQLEkEhC6Llb4T1D0Pb5x/BKOHRvizAUBfR0+vjUk",
+  "cUQUJlgB30tD9MAaAl8oWBjuLPJsVxePked7L8Zs+ukkD+8v8u7OrdzZeSPttqqJ50cTqpf1fGjwyVuYKo1LY0eYDbiRL/e9",
+  "tdOTf4pDq4GpmCo+d1Wv5Wsj/4F94SLa88KS7oQlPTC/S+htN3TkJWVGVvFRIIpheNKx40DIQ3sNUeL4i+7P8kf5v6NKF7Y+",
+  "cJJuwSEEMskXyx/nr09+kM5cwpuWKasX+XS3GQKbPhc7iGKlEinjFeXYJBwZUw4Nw9FRKFeVZbmDXNO5iatz/w2rSiw5Z3LK",
+  "WJJc3PPhEw82zjZKQ1PEkwHisVv7bu0o2JujUhKD9Yw4rBljWBexNXwrW8sX8nR1FUeTeYwmRRICxBisae7POk39eZEJLmjb",
+  "zoeLd3KB/SlV6cTO2DZKw+xAJvhxfCl/M3Et2ybXUKGItQZrqL/X1QvGCQEhXWaCRcEgZ+ee5S3Bg1zk/5RuOUKsnSgGcLHf",
+  "Yb1Kmc8Wbjz6yRqtUzXBho9V01XrbwsOp0Kc9NIro7wv9w3el/sWVe1hkPkcSeZxPJ7DSe1lzLVT0TwhPhZHmymxwBzlbH8n",
+  "K2UXBDHYTnKhEsZp4bM+WQEYlCAAgk4uie/jEn8rO7vWsitcxaCbz4QrIkDeVClQodOM02uGmGuHWGCPM9ccw9OxbBahSFV7",
+  "sLipKlNaYO1spXcaA5wwmJXZ69GZJSHCw7keBPAlZCl7WWqfAy/J+gBN3c+pxqgLcEGBf/i55ZkjynVvipnXpc2DgALEwoFh",
+  "4asPC284vZtL1yasrf6ctYXHmievmjoyJosOfRLnE2oqu7TVkjTP4RjA6OHZGZAFRLG4n5DYT6Rjq1O9PCOKZNli2r3J19Nm",
+  "bejmNlZ6RcCh5I3j0Bh8+vsBA1stF57heO0Cx4L21Pb3j8K2Q8K2/QZi4WtXRiBKmTaMa5/uc+sZ3lQtUVTTfL81QUgr0KKh",
+  "EnvxPzXSOmNzdMta5F375zxUyJs3hBUXm3QIsnXco6l7O1WVaWmPZu5RHXg5+MUgbHrS477dsGfYMhGmTOrOK2vmOt69Rtl4",
+  "TsLiHiEOG9ecaQiptb0oM7aZVYn8ovjlsm4t3nzsbbM2Rxu7w8O39pzdbu1DvpH2KNQIEZu9rj76KZnkJZvMqHdnG9WuYYRO",
+  "FfxAwHcQQ7UilDIGdOTA5jVV06oQxWBMg2Y1zZrqzElJQ16QjWEokPg58SPHyGgSnz/npqFpk6Qy21zg6BfnXlD0dZMXmDOI",
+  "FBeljQsaZiamBN+wgfq01/RkN+3+pKG1Z2rlqhTVY5d+W6FpLkNnmsWbVkZq1jwrgvgCgSEO3Z7JRK7o/ujRx2aaEZoxRd+8",
+  "AbtxC8mLn+vqmV/MXW/Q94rjLByFjFaR2Yu6p9T+Vm0eBGodlUkryPoSP24BxZRZKghqZFI93aUidx/yw78987qTo7MNUsup",
+  "nAcAOHnH/Iu7ErfVJSSZoGYgrxEFGyZGWsdIWwcKT2W2QF9mxyneJIiYEeQ359w0+MhstJzyqGw2NGHZhcoWkvKtvffk27z3",
+  "xJMaSlpJbZabtoJgyxzczDp96szQlmHkhpEdRUO/0waViWRT4abjV+lmLDsRbiH5ZUdlpx1NGVw8b25vWR/wfVkRl1ycwZxp",
+  "GJFSQTxVdZD1vl8CtRVVaZ6JnrV1pKlHFdBEkPrEHekxG/E7rY1Cni6Z4KKurfvHWHNqZ4rklRyBGxjA7b+1d9F837srsPxO",
+  "tq2pQMMKrqwYgTjWBCN2ujlkZUtVZw0mPTKDE2rHK5o5ldXqne8bm7oSpooTkPbcRQgd9w4lXLPwxqPHX25A+pc/MNFgSxO3",
+  "z3+np/rvjdOzUYpqZcgpP6tituRd/Jlch70kHnNJRoBpwANFVf28eGHFhSA2yImNqi7ODFmaA1OM12VNZVy/Han5L76JNxpY",
+  "L9CtMKlGtqu1/7tww5EfNQrq1Tsyo03jwfVxLBqaDUf+5/y2nhH9Sk74QzwgzqQmqZZgIYrZVYrNByxRZ96ar3q+nE6cHplD",
+  "swjXgyQSDVW+UnjTopvlvMej2daslS1PVfK/+qmx2qmMjTgBzXDCsBatpZpjt8+5MMBeYRLW41wfUFbLc5Fn7t1e9b91wR8f",
+  "LAO8+Lmunjkd+au8hHdIrMsUzalwVK19uGr4eveHj26rr9kAbNl5Rdu45v+vj0ybhWyZzNyxeU2ATo88W5/bvBn73A+W51pH",
+  "93WGIzP8a/9kZ389bSm8TLuniPbjNTIjY6L3ap8d/pdjRmvv8qUnaYV/+/zb51/k8/8ATqSGLedi1bsAAAAASUVORK5CYII="
+].join("");
+var FAVICON_PNG_DATA_URL = `data:image/png;base64,${FAVICON_PNG_BASE64}`;
+var FAVICON_PNG_BYTES = Uint8Array.from(atob(FAVICON_PNG_BASE64), (character) => character.charCodeAt(0));
+var FAVICON_SVG = `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 64 64">
+  <image width="64" height="64" href="${FAVICON_PNG_DATA_URL}"/>
+</svg>`;
+var CLASSIC_FAVICON_SVG = `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 64 64">
+  <rect width="64" height="64" rx="14" fill="#070b14"/>
+  <rect x="12" y="28" width="40" height="14" rx="3" fill="#E0BA55" opacity="0.35"/>
+  <text x="32" y="46" text-anchor="middle" font-family="Inter,system-ui,sans-serif" font-weight="800" font-size="42" fill="white">P</text>
+</svg>`;
+var CLASSIC_FAVICON_DATA_URL = `data:image/svg+xml;base64,${btoa(CLASSIC_FAVICON_SVG)}`;
+// ../../packages/shared/inbox/connection.ts
+function inboxClaimName(replyId, session) {
+  return `${replyId}.${session.replace(/[^A-Za-z0-9._-]/g, "_").slice(0, 120)}`;
+}
+var INBOX_TOOL_NAME = "plannotator_inbox";
+var INBOX_TOOL_ACTIONS = [
+  "send_message",
+  "read_thread",
+  "search",
+  "resolve_message",
+  "snooze_thread",
+  "submit_guide",
+  "get_guide_brief",
+  "card",
+  "steps"
+];
+var INBOX_REMOVED_ACTION = "wait_for_reply";
+var INBOX_REMOVED_ACTION_TEXT = "action_removed: The Plannotator Inbox no longer has wait_for_reply. Go on with your work or end your turn. If the reply does not arrive in this session by itself, call read_thread with the thread_id later.";
+var INBOX_FILLED_ARGUMENTS = ["project_path", "agent_session", "agent_host", "agent_name"];
+var INBOX_AGENT_PROJECT_PATH = "project_path";
+var INBOX_AGENT_PROJECT_PATH_DESCRIPTION = "The repository or folder this is about; defaults to the folder your session started in. Pass it only when the message is about another repository or folder.";
+function inboxProjectPathShapeRefusal(value) {
+  if (typeof value !== "string" || value.trim() === "")
+    return "project_path: a folder path (absolute, or relative to your working folder).";
+  if (/[\u0000-\u001f\u007f]/.test(value))
+    return "project_path: no control characters or line breaks.";
+  if (value.length > 4096)
+    return "project_path: at most 4096 characters.";
+  return null;
+}
+var INBOX_WAKES_META_KEY = "ai.plannotator/inbox-wakes";
+var INBOX_WORKING_FOLDER_META_KEY = "ai.plannotator/working-folder";
+function inboxToolCallParams(call, options) {
+  const meta = {
+    ...options.wakes ? { [INBOX_WAKES_META_KEY]: true } : {},
+    ...options.workingFolder ? { [INBOX_WORKING_FOLDER_META_KEY]: options.workingFolder } : {}
+  };
+  return { name: call.name, arguments: call.arguments, ...Object.keys(meta).length > 0 ? { _meta: meta } : {} };
+}
+var INBOX_REPLY_TO_CHECK = "Before reply_to into a thread you have not read in this context window, call read_thread with no id and match the subject.";
+var INBOX_REF_LINK_RULE = "A bare #123 links to this project's repository. For an issue or PR in another repo, write owner/repo#123 or its full URL (in a GitLab project, a GitHub one needs its URL).";
+var INBOX_PEEK_META_KEY = "ai.plannotator/inbox-peek";
+var INBOX_SESSION_THREADS_MAX = 5;
+var SESSION_THREAD_TEXT_MAX = 80;
+function inboxSessionThreadsParams(projectPath, session) {
+  return {
+    name: "read_thread",
+    arguments: { project_path: projectPath, agent_session: session, limit: INBOX_SESSION_THREADS_MAX },
+    _meta: { [INBOX_PEEK_META_KEY]: true }
+  };
+}
+function inboxHealthPeeks(health, serverSession) {
+  const value = health && typeof health === "object" ? health : null;
+  return !!value && value.serverSession === serverSession && value.peek === true;
+}
+var INBOX_SESSION_THREADS_MORE = 'More: read_thread with no id lists every thread (asked_by "anyone", include_resolved); search finds older ones by words (all_projects).';
+function inboxSessionThreadsText(result, toolName = INBOX_TOOL_NAME) {
+  const structured = result?.structuredContent;
+  if (!structured || !Array.isArray(structured.threads))
+    return null;
+  const oneLine = (value) => {
+    if (typeof value !== "string")
+      return null;
+    const flat = value.replace(/[\u061c\u200b-\u200f\u202a-\u202e\u2060-\u2064\u2066-\u2069\ufeff]/g, "").replace(/[\u0000-\u001f\u007f-\u009f\u2028\u2029]+/g, " ").replace(/\s+/g, " ").trim();
+    if (!flat)
+      return null;
+    return JSON.stringify(flat.length > SESSION_THREAD_TEXT_MAX ? `${flat.slice(0, SESSION_THREAD_TEXT_MAX - 1)}…` : flat);
+  };
+  const time = (value) => typeof value === "string" && /^\d{4}-\d\d-\d\dT\d\d:\d\d/.test(value) ? `${value.slice(0, 10)} ${value.slice(11, 16)}Z` : null;
+  const lines = [];
+  for (const row of structured.threads.slice(0, INBOX_SESSION_THREADS_MAX)) {
+    const thread = row;
+    const id = thread?.thread_id;
+    if (typeof id !== "string" || !/^msg_[0-9A-Za-z]{26}$/.test(id))
+      continue;
+    const parts = [`- ${id}`, oneLine(thread.subject) ?? "(no subject)"];
+    const name = oneLine(thread.thread_name);
+    if (name)
+      parts.push(`name ${name}`);
+    const questions = thread.questions;
+    const open = typeof questions?.open === "number" && questions.open > 0 ? questions.open : 0;
+    if (open > 0)
+      parts.push(`${open} open question${open === 1 ? "" : "s"}`);
+    if (thread.unread === true)
+      parts.push("the person wrote something you have not read");
+    const steps = thread.steps;
+    if (typeof steps?.done === "number" && typeof steps.total === "number" && steps.total > 0)
+      parts.push(`steps ${steps.done}/${steps.total}`);
+    const at = time(thread.last_at);
+    if (at)
+      parts.push(`last ${thread.last_author === "person" ? "the person" : "an agent"} ${at}`);
+    lines.push(parts.join(" · "));
+  }
+  if (lines.length === 0)
+    return null;
+  const total = typeof structured.total === "number" && structured.total > lines.length ? structured.total : lines.length;
+  const count = total > lines.length ? `${lines.length} of ${total}, newest first` : `${lines.length}`;
+  const check = INBOX_REPLY_TO_CHECK.replace("call read_thread", `call ${toolName} read_thread`);
+  return [`Your open Plannotator Inbox threads in this project (${count}). ${check} ${INBOX_SESSION_THREADS_CHANNEL}`, ...lines, INBOX_SESSION_THREADS_MORE].join(`
+`);
+}
+var INBOX_BRIDGE_POLL_PATH = "/api/inbox/bridge/poll";
+var INBOX_BRIDGE_EVENT_PATH = "/api/inbox/bridge/event";
+function parseInboxToolList(result) {
+  const listed = result && typeof result === "object" ? result.tools : undefined;
+  if (!Array.isArray(listed))
+    return [];
+  const byName = new Map;
+  for (const item of listed) {
+    if (!item || typeof item !== "object")
+      continue;
+    const tool = item;
+    if (typeof tool.name !== "string" || !INBOX_TOOL_ACTIONS.includes(tool.name))
+      continue;
+    const schema = tool.inputSchema && typeof tool.inputSchema === "object" ? tool.inputSchema : { type: "object" };
+    byName.set(tool.name, { name: tool.name, description: typeof tool.description === "string" ? tool.description : "", inputSchema: schema });
+  }
+  return INBOX_TOOL_ACTIONS.flatMap((name) => {
+    const tool = byName.get(name);
+    return tool ? [tool] : [];
+  });
+}
+function propertiesOf(tool) {
+  const properties = tool.inputSchema.properties;
+  return properties && typeof properties === "object" ? properties : {};
+}
+function isFilled(name) {
+  return INBOX_FILLED_ARGUMENTS.includes(name);
+}
+function leadOf(description) {
+  const line = description.split(`
+`, 1)[0] ?? "";
+  const stop = line.search(/\.\s/);
+  return (stop >= 0 ? line.slice(0, stop + 1) : line).trim();
+}
+var INBOX_CHANNEL_RULE = "A decision in the Inbox stays there: when the person writes in the chat, say what waits and link its thread, but never also ask it in the chat with a blocking question tool (AskUserQuestion or similar). Ask in the chat only about something new they raised there that needs no pictures or files, or when they ask.";
+var INBOX_SESSION_THREADS_CHANNEL = "Their decisions stay in these threads: when the person writes in the chat, say what waits and link the thread, but never also ask it in the chat with a blocking question tool (AskUserQuestion or similar).";
+var INBOX_USE_RULE = "Use it for a decision only they can make (a :::question block; go on with other work), finished long work (a short summary with its pictures inline, files in `attachments`), or when they ask.";
+var INBOX_THREAD_RULE = "One thread per work stream, unless the person says otherwise.";
+var INBOX_FOLLOW_THROUGH_RULE = "Be proactive about Inbox updates and about replying to the person through the Inbox when you think they would want you to. Don't withhold important updates or decisions, and don't batch updates to send later: proactivity is better than procrastination.";
+var INBOX_SUBAGENT_RULE = "If another agent started you, report to it instead.";
+var INBOX_AGENT_RULES = `${INBOX_USE_RULE} ${INBOX_THREAD_RULE} ${INBOX_CHANNEL_RULE} ${INBOX_FOLLOW_THROUGH_RULE} ${INBOX_SUBAGENT_RULE}`;
+var INBOX_TOOL_LEAD = `The Plannotator Inbox on this machine: message the person, get their answer later; nothing blocks. ${INBOX_AGENT_RULES} Set \`action\` to a tool below, with its fields.`;
+var INBOX_TOOL_WAKE_NOTE = "A reply arrives in this session by itself once it is idle, headed `Plannotator Inbox: <title> (<reply id>)`: end your turn or keep working. To answer it, send_message with reply_to set to that reply id, never one from memory.";
+var INBOX_TOOL_HELP_NOTE = "Every field and question syntax: `plannotator inbox --help`.";
+var INBOX_TOOL_BOARD_OFF_NOTE = "The Board (cards for work that outlasts a reply) is off until the person turns it on; see `plannotator card --help`.";
+var INBOX_STEPS_LEAD = "The person's checklist for this thread, only for multi-step work you're both aligned on. High-level steps, a few plain words each; never your own to-do list. The whole list each call. status: todo, doing, done, waiting (on the person), dropped (say why in note). Update each step as it starts and ends; notifies no one.";
+var INBOX_STEPS_ACTION_LINE = "person's checklist for multi-step work you're aligned on (see the steps field).";
+var INBOX_STEPS_FIELD_DESCRIPTION = `steps: ${INBOX_STEPS_LEAD} No thread yet: send it with the send_message that starts one.`;
+function inboxStepsWakeLine(steps) {
+  return `Your checklist here: ${steps.done} of ${steps.total} done${steps.doing ? `; doing: ${steps.doing}` : ""}. If you're still working on this, keep it current.`;
+}
+function wakeSteps(value) {
+  if (!value || typeof value !== "object")
+    return null;
+  const { done, total, doing } = value;
+  const count = (n) => typeof n === "number" && Number.isInteger(n) && n >= 0 && n <= 12;
+  if (!count(done) || !count(total) || total === 0 || done > total)
+    return null;
+  const step = typeof doing === "string" ? doing.replace(/[\p{Cc}\p{Zl}\p{Zp}]+/gu, " ").replace(/\s+/g, " ").trim().slice(0, 80) : "";
+  return { done, total, doing: step || null };
+}
+var INBOX_AGENT_ACTIONS_NO_LINE = ["snooze_thread"];
+var INBOX_AGENT_ACTION_LEADS = {
+  send_message: "Message the person (markdown), in your session's open thread (see `thread`).",
+  resolve_message: "Archive a message's thread, only when nothing in it is left for the person to read or answer.",
+  read_thread: 'Read a thread (thread_id); with no id, list your threads (asked_by "anyone": all).',
+  search: "Find messages by words, older ones too (read-only).",
+  get_guide_brief: "How to write a guided review, with a worked submit_guide call.",
+  card: "A Board card for work that outlasts this reply: create it, then move it and say where it is as the work moves.",
+  steps: INBOX_STEPS_ACTION_LINE
+};
+var INBOX_PICTURES_RULE = "Pictures go in the body where you write about them, `![alt](/abs/path.png)`, never only in `attachments`; do not also attach one the body shows. Visual options are picture choices, one picture each, inside the choice (not in the text above the question): `- [ ] A · Label — ![alt](path) what it means`; the label comes back.";
+var INBOX_ATTACHMENTS_PICTURES_LINE = "Screenshots and pictures go in the body instead (`![alt](path)`); attach what the person should open or click through.";
+var INBOX_AGENT_FIELD_DESCRIPTIONS = {
+  send_message: {
+    body: [
+      "The message, markdown. Ask what only the person can decide as a question block, which renders as an answerable card:",
+      "",
+      ":::question",
+      "Where should the edit that loses a sync conflict go?",
+      "",
+      "Context in one to three plain sentences: what it affects, what you know, why you recommend one. The person switches in cold.",
+      "",
+      "- [ ] Nowhere — silent loss, as today",
+      "- [ ] Local only, purged after 30 days — cheap",
+      "- [ ] Server-side per user — needs a retention policy",
+      "",
+      "Recommended: Local only, purged after 30 days",
+      "Holds up: sync release",
+      ":::",
+      "",
+      'Your recommendation goes on the `Recommended:` line, never in a choice label. Keep the choices in their natural order; never move yours first. `:::question-multi` takes several choices, `:::question-text` free text. The person can always answer Other, add a note or skip, so never add an Other choice yourself. `Stopped: <why>` only when you cannot go on until it is answered (never `Stopped: no`); `Holds up: <work>` names work that waits while you go on. Ask only what you cannot decide alone, about 8 a round at most. Answers come back in the reply under "Answers to your questions".',
+      "",
+      INBOX_PICTURES_RULE,
+      "",
+      "Optional lines after the question; most questions need none of these: `Stakes: <what it affects>` (give one with every Stopped or Holds up), `Shows: ![alt](path)` or `Shows: [name](file)` (the one picture or file it is about), `Why: <why your recommendation>` on its own line, `Reversible: no — <why>` only when it cannot be undone.",
+      "",
+      'Only for a true blocker the person must go and do outside this chat, that you cannot do yourself (approve a deploy, sign in, touch a security key, merge a PR you cannot merge), write a `:::action` block: first line the order, then why. Each command the person must run goes in the why in its own fenced code block (```), one block per command in the order to run them, so each gets a copy button. Optional: `Where: <url>`, `Stopped:`, `Watching: <what you watch>`. Never for a decision or a question, for what you can do yourself, or as a checklist or status update; most messages need none. Done or Can\'t do it comes back under "Action items you asked for".',
+      "",
+      "Blocks fenced as `mermaid` or `dot` draw as diagrams; one fenced as `html` draws as a live, sandboxed page in the message (chart, SVG, mock; https libraries load). Leave its background transparent; use var(--foreground), var(--chart-1)…var(--chart-5). Let content set its height: no vh units or height:100% on html or body.",
+      "",
+      INBOX_REF_LINK_RULE
+    ].join(`
+`),
+    reply_to: `A message id: post this as a reply in that message's thread. ${INBOX_REPLY_TO_CHECK}`,
+    thread: "A short thread name, one line, to keep separate work apart: the same name in this project is the same open thread, across sessions. Without it, your messages join your session's open thread. Ignored with reply_to, except when you are asked to name a thread the person started: then it names that thread, once.",
+    supersedes: `Your own questions in this thread that are still open (read_thread state open or picked) and no longer apply: a newer message replaces them, or the reply settled them in words. "<message id>/<key>" for one, "<message id>" for all of that message's; send with reply_to into their thread. With one question in this message it replaces them, otherwise they read "No longer applies".`,
+    done: 'Your own open action items (`:::action`) in this thread that you saw done yourself, e.g. the deploy you watch is Ready: "<message id>/<key>" (key a-…); send with reply_to into their thread. The card says you saw it done; nothing is sent to the person.',
+    attachments: `Files to show the person beside the message, absolute or relative to project_path: a plan, an HTML mock, code, a video, any file. ${INBOX_ATTACHMENTS_PICTURES_LINE} Link one from the body (\`[the mock](mock.html)\`) to open it beside the thread. Their comments on the files come back in the reply. Folders and .env files are refused.`
+  },
+  read_thread: {
+    thread_id: "A thread id. read_thread shows its open questions, the newest messages in full, and earlier ones one line each."
+  },
+  submit_guide: {
+    guide: "The guide in get_guide_brief's output_schema, as an object or its JSON.",
+    snapshot: "Instead of guide and patch: a complete Plannotator guide snapshot, as an object or its JSON."
+  }
+};
+var INBOX_REMINDER_TEXT = `Plannotator Inbox is on: when you finish long work, or need a decision only the person can make, send it with plannotator_inbox send_message (each decision as a \`:::question\` block) and keep going. ${INBOX_FOLLOW_THROUGH_RULE} ${INBOX_THREAD_RULE} Their reply comes back here. A decision in the Inbox stays there: when the person writes here, say what waits and link its thread, but never also ask it in the chat with a blocking question tool (AskUserQuestion or similar). Run \`plannotator inbox --help\` for how it works.`;
+var INBOX_REMINDER_TEXT_NO_WAKE = `Plannotator Inbox is on: when you finish long work, or need a decision only the person can make, send it with plannotator_inbox send_message (each decision as a \`:::question\` block) and keep going. ${INBOX_FOLLOW_THROUGH_RULE} ${INBOX_THREAD_RULE} Their reply does not come back here by itself: read the thread later with read_thread. A decision in the Inbox stays there: when the person writes here, say what waits and link its thread, but never also ask it in the chat with a blocking question tool (AskUserQuestion or similar). Run \`plannotator inbox --help\` for how it works.`;
+var INBOX_BRIEFING_NEVER_RUN = "Never run `plannotator inbox` just to send: send_message starts a stopped Inbox itself, and bare `plannotator inbox` opens the window for the person.";
+var INBOX_BRIEFING_FROM_NOW_ON = "For the rest of this session, use the Inbox as above: for a decision the person is not here to make, and to hand over long work you finished.";
+var INBOX_COMMAND_BRIEFING = [
+  "The person opened their Plannotator Inbox with /plannotator-inbox and has its address. The Plannotator Inbox is one window on this computer where you leave the person messages, `:::question` blocks they answer with a click, and files. They answer when they can. Nothing blocks: you send, then keep working or end your turn.",
+  "",
+  `- ${INBOX_USE_RULE}`,
+  `- ${INBOX_THREAD_RULE}`,
+  "- Send with a `plannotator_inbox` tool when you have one (it can be listed with a prefix and may need loading through tool search first): `action` `send_message`, with a markdown `body`. Otherwise call `send_message` on the Inbox's MCP server, `plannotator inbox mcp`.",
+  "- send_message's result says whether the person's reply arrives in this session by itself. When it does, do not wait or poll for it: end your turn or go on with other work. When it does not, go on with your work and read the thread later with read_thread.",
+  `- ${INBOX_CHANNEL_RULE}`,
+  `- ${INBOX_FOLLOW_THROUGH_RULE}`,
+  `- ${INBOX_BRIEFING_NEVER_RUN}`,
+  "- Before your first send, run `plannotator inbox --help` and read it: every field, the full question syntax, and how to connect the MCP server.",
+  "- The `plannotator` skill, where you have it, has more.",
+  "",
+  `Opening the Inbox asks for no work by itself. ${INBOX_BRIEFING_FROM_NOW_ON}`
+].join(`
+`);
+function inboxAgentTool(tools, options = {}) {
+  if (tools.length === 0)
+    return null;
+  const description = [
+    INBOX_TOOL_LEAD,
+    "",
+    ...tools.filter((tool) => !INBOX_AGENT_ACTIONS_NO_LINE.includes(tool.name)).map((tool) => `- ${tool.name}: ${INBOX_AGENT_ACTION_LEADS[tool.name] ?? leadOf(tool.description)}`),
+    ...options.wakes === false ? [] : ["", INBOX_TOOL_WAKE_NOTE],
+    "",
+    ...tools.some((tool) => tool.name === "card") ? [] : [INBOX_TOOL_BOARD_OFF_NOTE],
+    INBOX_TOOL_HELP_NOTE
+  ].join(`
+`);
+  const properties = {
+    action: { type: "string", enum: tools.map((tool) => tool.name), description: "Which Inbox tool to call." }
+  };
+  const usedBy = new Map;
+  for (const tool of tools) {
+    for (const [name, schema] of Object.entries(propertiesOf(tool))) {
+      if (isFilled(name) && name !== INBOX_AGENT_PROJECT_PATH || name === "action")
+        continue;
+      const users = usedBy.get(name);
+      if (users) {
+        users.push(tool.name);
+        continue;
+      }
+      usedBy.set(name, [tool.name]);
+      if (name === INBOX_AGENT_PROJECT_PATH) {
+        properties[name] = { type: "string", description: INBOX_AGENT_PROJECT_PATH_DESCRIPTION };
+        continue;
+      }
+      const own = INBOX_AGENT_FIELD_DESCRIPTIONS[tool.name]?.[name];
+      properties[name] = { ...schema, description: (own ?? (typeof schema.description === "string" ? schema.description : "")).trim() };
+    }
+  }
+  for (const [name, users] of usedBy) {
+    const schema = properties[name];
+    properties[name] = { ...schema, description: `(${users.join(", ")}) ${schema.description}`.trim() };
+  }
+  return { name: INBOX_TOOL_NAME, description, inputSchema: { type: "object", properties, required: ["action"], additionalProperties: false } };
+}
+function inboxToolCall(input, tools, filled) {
+  if (!input || typeof input !== "object" || Array.isArray(input))
+    return { error: "Invalid plannotator_inbox call: expected an object with an action." };
+  const { action, ...rest } = input;
+  if (action === INBOX_REMOVED_ACTION)
+    return { error: INBOX_REMOVED_ACTION_TEXT };
+  const tool = tools.find((candidate) => candidate.name === action);
+  if (!tool) {
+    return {
+      error: `Invalid plannotator_inbox call: action must be one of ${tools.map((candidate) => candidate.name).join(", ")}${typeof action === "string" && INBOX_TOOL_ACTIONS.includes(action) ? ` (this Plannotator Inbox has no ${action}; update Plannotator for it)` : ""}.`
+    };
+  }
+  const own = propertiesOf(tool);
+  const args = {};
+  let projectPath;
+  for (const [name, value] of Object.entries(rest)) {
+    if (value === undefined)
+      continue;
+    if (name === INBOX_AGENT_PROJECT_PATH && name in own) {
+      const refusal = inboxProjectPathShapeRefusal(value);
+      if (refusal)
+        return { error: `Invalid plannotator_inbox call: ${refusal}` };
+      projectPath = value;
+      continue;
+    }
+    if (!(name in own) || isFilled(name)) {
+      const fields = Object.keys(own).filter((field) => !isFilled(field) || field === INBOX_AGENT_PROJECT_PATH);
+      return { error: `Invalid plannotator_inbox call: ${tool.name} takes no "${name}" (its fields: ${fields.join(", ") || "none"}).` };
+    }
+    args[name] = value;
+  }
+  for (const name of INBOX_FILLED_ARGUMENTS)
+    if (name in own)
+      args[name] = filled[name];
+  return projectPath === undefined ? { name: tool.name, arguments: args } : { name: tool.name, arguments: args, projectPath };
+}
+var INBOX_TEXT_COMPLETE_META_KEY = "ai.plannotator/text-complete";
+function inboxToolResultText(result) {
+  const value = result && typeof result === "object" ? result : {};
+  const text = Array.isArray(value.content) ? value.content.map((part) => part && typeof part === "object" && typeof part.text === "string" ? part.text : "").filter(Boolean).join(`
+`) : "";
+  const meta = value._meta && typeof value._meta === "object" ? value._meta : {};
+  const complete = meta[INBOX_TEXT_COMPLETE_META_KEY] === true;
+  const structured = !complete && value.structuredContent && typeof value.structuredContent === "object" ? `
+
+${JSON.stringify(value.structuredContent)}` : "";
+  return { text: `${text}${value.isError === true ? "" : structured}`.trim(), isError: value.isError === true };
+}
+function mcpAnswerOf(text) {
+  const candidates = /^\s*(event:|data:|:)/m.test(text) ? text.split(/\r?\n\r?\n/).map((block) => block.split(/\r?\n/).filter((line) => line.startsWith("data:")).map((line) => line.slice(5).replace(/^ /, "")).join(`
+`)).filter((data) => data.trim()) : [text];
+  for (const candidate of candidates) {
+    try {
+      const value = JSON.parse(candidate);
+      if (value && typeof value === "object" && (("result" in value) || ("error" in value)))
+        return value;
+    } catch {}
+  }
+  return null;
+}
+var INBOX_MAX_REQUEST_BYTES = 128 * 1024 * 1024;
+function inboxRequestTooLargeMessage(bytes) {
+  const size = bytes === undefined ? "" : ` (${bytes} bytes)`;
+  return `The message is too large for the Plannotator Inbox${size}: one request may carry at most ${INBOX_MAX_REQUEST_BYTES} bytes (128 MiB). Send a smaller message, or attach the content as a file.`;
+}
+function mcpAnswerOfResponse(status, text) {
+  return mcpAnswerOf(text) ?? (status === 413 ? { error: { message: inboxRequestTooLargeMessage() } } : null);
+}
+function parseInboxRegistry(text) {
+  if (!text)
+    return null;
+  try {
+    const value = JSON.parse(text);
+    if (value.v === 1 && typeof value.pid === "number" && typeof value.port === "number" && Number.isInteger(value.port) && value.port > 0 && value.port < 65536 && typeof value.token === "string" && value.token.length >= 32 && typeof value.serverSession === "string" && typeof value.url === "string") {
+      return { pid: value.pid, port: value.port, token: value.token, serverSession: value.serverSession, url: value.url };
+    }
+  } catch {}
+  return null;
+}
+var INBOX_TAGS_POLL_FIELD = "tags";
+var INBOX_TAGGED_INSTRUCTION = "The person tagged you in a Plannotator Inbox thread that another session owns. Their reply follows as they wrote it; parts of it may be meant for the other session, not for you.";
+function inboxTaggedLine(owner, id) {
+  return `The thread belongs to another session (${owner}); you have not seen it. Read it first with read_thread (message_id ${id}). Answer only what is addressed to you, in the same thread: plannotator_inbox send_message with reply_to ${id}.`;
+}
+function inboxAlsoTaggedLine(names) {
+  const list = names.length <= 1 ? names[0] ?? "another session" : `${names.slice(0, -1).join(", ")} and ${names[names.length - 1]}`;
+  return `This reply also tags ${list} (other sessions); each gets it too. Leave what is addressed to them to them.`;
+}
+var INBOX_ADDED_INSTRUCTION = "The person added you to a Plannotator Inbox thread that another session owns: you work on it alongside that session, and their later replies in it come to you too. Their reply follows as they wrote it; parts of it may be meant for the other session.";
+function inboxAddedLine(owner, id) {
+  return `The thread's owner is ${owner}. If you have not read the thread yet, read it first with read_thread (message_id ${id}). Answer your part in the same thread: plannotator_inbox send_message with reply_to ${id}.`;
+}
+var INBOX_HANDOFF_INSTRUCTION = "The person handed you this Plannotator Inbox thread: it is yours now, and their later replies in it come to you. Their reply follows as they wrote it.";
+function inboxHandoffLine(from, id) {
+  return `Another session (${from}) had this thread before; you have not seen it. Read it first with read_thread (message_id ${id}), then answer in it: plannotator_inbox send_message with reply_to ${id}.`;
+}
+function inboxHandedAwayLine(to) {
+  return `The person handed this thread to another session (${to}); their later replies in it go there. Stop work on it, and write in it only if they ask you to.`;
+}
+var INBOX_WAKE_AGENT_NAMES = ["Claude Code", "Pi", "OpenCode", "Codex", "Cursor", "Grok Build", "Qwen Code"];
+function wakeName(value) {
+  if (typeof value !== "string")
+    return "";
+  const name = value.replace(/[\u0000-\u001f\u007f-\u009f\s]+/g, " ").trim();
+  return INBOX_WAKE_AGENT_NAMES.includes(name) ? name : "";
+}
+var INBOX_SEND_NOW_POLL_FIELD = "send_now";
+var INBOX_STEER_POLLS_POLL_FIELD = "steer_polls";
+function parseInboxBridgeCommands(text) {
+  try {
+    const body = JSON.parse(text);
+    if (!Array.isArray(body.commands))
+      return [];
+    return body.commands.filter((command) => {
+      if (!command || typeof command !== "object")
+        return false;
+      const c = command;
+      return (c.type === "reply" || c.type === "message") && typeof c.id === "string" && typeof c.thread_id === "string" && typeof c.body === "string";
+    });
+  } catch {
+    return [];
+  }
+}
+var INBOX_WAKE_INSTRUCTION = "This is a user reply from Plannotator Inbox. Their reply follows as they wrote it: it is their answer to you. When they need to hear back, answer in the same thread: plannotator_inbox send_message with reply_to set to the id in parentheses on the line above.";
+var INBOX_REASK_INSTRUCTION = "The person asked, from the Plannotator Inbox, for the open questions in this thread to be asked again, together in one new message. The questions and what to do with each follow. Answer in the same thread: plannotator_inbox send_message with reply_to set to the id in parentheses on the line above.";
+var reaskWords = (items) => items === "actions" ? { what: "open action items", they: "The action items" } : items === "both" ? { what: "open questions and action items", they: "They" } : { what: "open questions", they: "The questions" };
+function inboxReaskInstruction(items, one = false) {
+  if (one && items !== "both") {
+    const what2 = items === "actions" ? "action item" : "question";
+    return `The person asked, from the Plannotator Inbox, for the open ${what2} in this thread to be asked again, in one new message. The ${what2} and what to do with it follow. Answer in the same thread: plannotator_inbox send_message with reply_to set to the id in parentheses on the line above.`;
+  }
+  if (items !== "actions" && items !== "both")
+    return INBOX_REASK_INSTRUCTION;
+  const { what, they } = reaskWords(items);
+  return `The person asked, from the Plannotator Inbox, for the ${what} in this thread to be asked again, together in one new message. ${they} and what to do with each follow. Answer in the same thread: plannotator_inbox send_message with reply_to set to the id in parentheses on the line above.`;
+}
+function inboxReaskRedirectedLine(asker, id, items, one = false) {
+  if (one && items !== "both") {
+    const what = items === "actions" ? "This action item" : "This question";
+    return `${what} was asked by another ${asker} session, which has ended; the person picked you to take it over. Read the thread first with read_thread (message_id ${id}), then ask it again as below if it is still needed.`;
+  }
+  const these = items === "actions" ? "These action items" : items === "both" ? "These questions and action items" : "These questions";
+  return `${these} were asked by another ${asker} session, which has ended; the person picked you to take them over. Read the thread first with read_thread (message_id ${id}), then ask the ones still needed again as below.`;
+}
+var INBOX_MESSAGE_INSTRUCTION = "The person wrote to you from the Plannotator Inbox. Their message follows as they wrote it: it is from them, not from the Inbox. When they need to hear back, answer in the same thread: plannotator_inbox send_message with reply_to set to the id in parentheses on the line above.";
+var INBOX_NEW_THREAD_INSTRUCTION = "The person started a new thread with you in the Plannotator Inbox: an idea or a request of their own, not an answer to something you asked. Their message follows as they wrote it. It may be unrelated to what you were doing; say how you will handle it before you start. When they need to hear back, answer in the same thread: plannotator_inbox send_message with reply_to set to the id in parentheses on the line above.";
+var INBOX_NAME_THREAD_LINE = "Name this thread in your reply: pass `thread` with a few words saying what it is about. The first name you give sets it, once.";
+function inboxContinuesLine(id) {
+  return `This continues a thread the person started with another session; you have not seen it. Read it first with read_thread (message_id ${id}), then answer in it with reply_to ${id}.`;
+}
+function inboxRedirectedLine(asker, id) {
+  return `This reply was written to another ${asker} session that has ended. Read the thread with read_thread to see what it asked, then answer with reply_to ${id}.`;
+}
+function inboxAckLine(messageId) {
+  return `The person marked your message \uD83D\uDC4D Looks good (${messageId}). No reply needed unless you have a question.`;
+}
+function wakeThreadId(value) {
+  return typeof value === "string" && /^msg_[0-9A-Za-z]{1,64}$/.test(value) ? value : "";
+}
+var INBOX_WAKE_CLOSING_LINE = "[for context: read_thread (opt: set limit) or search · help: plannotator inbox --help]";
+function inboxWakeAgo(at, now) {
+  const then = typeof at === "string" ? Date.parse(at) : Number.NaN;
+  if (!Number.isFinite(then))
+    return "";
+  const minutes = Math.floor((now - then) / 60000);
+  if (minutes < 1)
+    return "just now";
+  if (minutes < 2)
+    return "a minute ago";
+  if (minutes < 60)
+    return `${minutes} minutes ago`;
+  const hours = Math.floor(minutes / 60);
+  if (hours < 2)
+    return "an hour ago";
+  if (hours < 24)
+    return `${hours} hours ago`;
+  const days = Math.floor(hours / 24);
+  return days < 2 ? "a day ago" : `${days} days ago`;
+}
+var wakeCount = (value) => typeof value === "number" && Number.isSafeInteger(value) && value >= 0 ? value : null;
+var wakePlural = (n, word) => `${n} ${word}${n === 1 ? "" : "s"}`;
+function inboxWakeDetailsLine(threadId, context, options) {
+  const thread = wakeThreadId(threadId);
+  if (!thread || !context || typeof context !== "object")
+    return "";
+  const { messages, open_questions, open_actions, last_agent_at } = context;
+  const count = wakeCount(messages);
+  const questions = wakeCount(open_questions);
+  const actions = wakeCount(open_actions);
+  if (count === null || questions === null || actions === null)
+    return "";
+  const open = [];
+  if (questions > 0)
+    open.push(`${wakePlural(questions, "question")} open${options.reask ? "" : `, don't re-ask ${questions === 1 ? "it" : "them"}`}`);
+  if (actions > 0)
+    open.push(`${wakePlural(actions, "action item")} open`);
+  const state = open.join(", ") || (options.queued ? "" : "nothing open");
+  const ago = inboxWakeAgo(last_agent_at, options.now);
+  return `[Thread ${thread}: ${wakePlural(count, "message")}${state ? `, ${state}` : ""}${ago ? `. Your last message was ${ago}` : ""}]`;
+}
+function wakeQuote(value) {
+  if (typeof value !== "string")
+    return "";
+  const flat = value.replace(/[\p{Cc}\p{Cs}\p{Zl}\p{Zp}]+/gu, " ").replace(/\p{Cf}+/gu, "").replace(/[[\]]/g, "").replace(/"/g, "'").replace(/\s+/g, " ").trim();
+  const chars = [...flat];
+  return chars.length > 120 ? `${chars.slice(0, 120).join("").trimEnd()}…` : flat;
+}
+function inboxWakeReplyingLine(target, now) {
+  if (!target || typeof target !== "object")
+    return "";
+  const { id, at, quote, questions, actions } = target;
+  const message = wakeThreadId(id);
+  const ago = inboxWakeAgo(at, now);
+  if (!message || !ago)
+    return "";
+  const head = `Replying to your message from ${ago} (${message})`;
+  const words = wakeQuote(quote);
+  if (words)
+    return `[${head}: "${words}"]`;
+  const asked = [];
+  if ((wakeCount(questions) ?? 0) > 0)
+    asked.push(wakePlural(questions, "question"));
+  if ((wakeCount(actions) ?? 0) > 0)
+    asked.push(wakePlural(actions, "action item"));
+  return `[${head}${asked.length > 0 ? `, with ${asked.join(" and ")}` : ""}]`;
+}
+function inboxWakeCommand(command) {
+  if (!command.context || typeof command.context !== "object")
+    return command;
+  const { still_open_line: line, still_open_at: at, ...context } = command.context;
+  if (typeof line !== "string" || line === "")
+    return command;
+  if (!inboxWakeDetailsLine(command.thread_id, context, { now: 0 }) || !wakeCount(context.open_questions))
+    return { ...command, context };
+  if (typeof at !== "number" || !Number.isSafeInteger(at) || at < 0 || !command.body.startsWith(line, at))
+    return { ...command, context };
+  const end = at + line.length;
+  const alone = (at === 0 || command.body.slice(at - 2, at) === `
+
+`) && (end === command.body.length || command.body.slice(end, end + 2) === `
+
+`);
+  if (!alone)
+    return { ...command, context };
+  const body = [command.body.slice(0, Math.max(0, at - 2)), command.body.slice(end + 2)].filter((part) => part !== "").join(`
+
+`);
+  return { ...command, context, body: body === "" ? command.body : body };
+}
+function inboxWakeText(command, now = Date.now(), wording = {}) {
+  if (command.tidy === true) {
+    return `Plannotator Inbox: ${(command.subject ?? "").replace(/\s+/g, " ").trim() || "Tidy"} (${command.id})
+${command.body}
+
+${INBOX_WAKE_CLOSING_LINE}`;
+  }
+  if (typeof command.ack_of === "string" && command.ack_of !== "") {
+    const ackSubject = (command.subject ?? "").replace(/\s+/g, " ").trim() || "a message";
+    const thread2 = wakeThreadId(command.thread_id);
+    return `Plannotator Inbox: ${ackSubject} (${command.id})
+${inboxAckLine(command.ack_of)}${thread2 ? `
+
+[thread ${thread2}]` : ""}`;
+  }
+  const steps = wakeSteps(command.steps);
+  const closing = `${steps ? `
+
+${inboxStepsWakeLine(steps)}` : ""}
+
+${INBOX_WAKE_CLOSING_LINE}`;
+  const { body, context } = inboxWakeCommand(command);
+  const details = inboxWakeDetailsLine(command.thread_id, context, { now, reask: command.reask === true, queued: wording.queued === true });
+  const target = details ? inboxWakeReplyingLine(context.replying_to, now) : "";
+  const thread = wakeThreadId(command.thread_id);
+  const facts = details ? `
+${details}${target ? `
+${target}` : ""}` : thread ? `
+[Thread ${thread}]` : "";
+  const subject = (command.subject ?? "").replace(/\s+/g, " ").trim() || (command.type === "message" ? "a message" : "a reply");
+  if (command.handed_away && typeof command.handed_away === "object") {
+    const to = wakeName(command.handed_away.to) || "another agent";
+    return `Plannotator Inbox: ${subject} (${command.id})
+${inboxHandedAwayLine(to)}${facts}${closing}`;
+  }
+  if (command.handoff && typeof command.handoff === "object") {
+    const from = wakeName(command.handoff.from) || "another agent";
+    return `Plannotator Inbox: ${subject} (${command.id})
+${INBOX_HANDOFF_INSTRUCTION}
+${inboxHandoffLine(from, command.id)}${facts}
+
+${body}${closing}`;
+  }
+  if (command.tagged && typeof command.tagged === "object") {
+    const owner = wakeName(command.tagged.owner) || "another agent";
+    if (command.added === true) {
+      return `Plannotator Inbox: ${subject} (${command.id})
+${INBOX_ADDED_INSTRUCTION}
+${inboxAddedLine(owner, command.id)}${facts}
+
+${body}${closing}`;
+    }
+    return `Plannotator Inbox: ${subject} (${command.id})
+${INBOX_TAGGED_INSTRUCTION}
+${inboxTaggedLine(owner, command.id)}${facts}
+
+${body}${closing}`;
+  }
+  const others = Array.isArray(command.also_tagged) ? command.also_tagged.filter((name) => typeof name === "string" && name.trim() !== "").map((name) => wakeName(name) || "another agent").slice(0, 8) : [];
+  const also = others.length > 0 ? `
+${inboxAlsoTaggedLine(others)}` : "";
+  const reaskItems = command.reask_items === "actions" || command.reask_items === "both" ? command.reask_items : undefined;
+  const reaskOne = command.reask_one === true;
+  const instruction = command.type === "message" ? command.new_thread === true ? INBOX_NEW_THREAD_INSTRUCTION : INBOX_MESSAGE_INSTRUCTION : command.reask === true ? inboxReaskInstruction(reaskItems, reaskOne) : INBOX_WAKE_INSTRUCTION;
+  const asker = command.type !== "message" && typeof command.redirected_from === "string" && command.redirected_from.trim() !== "" ? wakeName(command.redirected_from) || "agent" : "";
+  const redirected = asker ? `
+${command.reask === true ? inboxReaskRedirectedLine(asker, command.id, reaskItems, reaskOne) : inboxRedirectedLine(asker, command.id)}` : command.continues_thread === true ? `
+${inboxContinuesLine(command.id)}` : "";
+  const naming = command.name_thread === true ? `
+${INBOX_NAME_THREAD_LINE}` : "";
+  return `Plannotator Inbox: ${subject} (${command.id})
+${instruction}${redirected}${also}${naming}${facts}
+
+${body}${closing}`;
+}
+
+// ../../packages/shared/config.ts
+function getConfigDir() {
+  return getPlannotatorDataDir();
+}
+function getConfigPath() {
+  return join2(getConfigDir(), "config.json");
+}
+function loadConfig(options = {}) {
+  try {
+    const configPath = getConfigPath();
+    if (!existsSync2(configPath))
+      return {};
+    const raw = readFileSync(configPath, "utf-8").replace(/^\uFEFF/, "");
+    const parsed = JSON.parse(raw);
+    return typeof parsed === "object" && parsed !== null && !Array.isArray(parsed) ? parsed : {};
+  } catch (e) {
+    if (!options.quiet)
+      process.stderr.write(`[plannotator] Warning: failed to read config.json: ${e}
+`);
+    return {};
+  }
+}
+function parseConfigBoolean(value) {
+  if (typeof value === "boolean")
+    return value;
+  if (typeof value === "string") {
+    const v = value.trim().toLowerCase();
+    if (v === "true" || v === "1")
+      return true;
+    if (v === "false" || v === "0")
+      return false;
+  }
+  return;
+}
+var AGENT_TOOL_DEFAULTS = {
+  "claude-code": true,
+  pi: false,
+  "oh-my-pi": true,
+  opencode: false,
+  dsh: false
+};
+var INBOX_TOOL_DEFAULTS = {
+  "claude-code": AGENT_TOOL_DEFAULTS["claude-code"],
+  pi: AGENT_TOOL_DEFAULTS.pi,
+  opencode: AGENT_TOOL_DEFAULTS.opencode,
+  dsh: AGENT_TOOL_DEFAULTS.dsh,
+  cline: false
+};
+function parseInboxToolEnv(env = process.env) {
+  const v = env.PLANNOTATOR_INBOX_TOOL?.trim().toLowerCase();
+  if (v === "1" || v === "true" || v === "on")
+    return true;
+  if (v === "0" || v === "false" || v === "off" || v === "disabled")
+    return false;
+  return;
+}
+function configuredInboxTool(config, host) {
+  const value = config.inboxTool;
+  if (value && typeof value === "object" && !Array.isArray(value)) {
+    return parseConfigBoolean(value[host]);
+  }
+  return parseConfigBoolean(value);
+}
+function resolveInboxTool(config, env, host) {
+  return parseInboxToolEnv(env) ?? configuredInboxTool(config, host) ?? INBOX_TOOL_DEFAULTS[host];
+}
+var warnedInvalidGuideShareUrls = new Set;
+var warnedInvalidPublicUrls = new Set;
+var warnedInvalidUrlHosts = new Set;
+var warnedBitbucketApiUrls = new Set;
+
+// ../../packages/shared/inbox/agent-link.ts
+import { spawn } from "node:child_process";
+import { randomUUID } from "node:crypto";
+import { chmodSync, existsSync as existsSync3, mkdirSync as mkdirSync2, readFileSync as readFileSync2, realpathSync as realpathSync2, renameSync as renameSync2, rmSync, statSync as statSync2, writeFileSync as writeFileSync2 } from "node:fs";
+import { homedir as homedir2 } from "node:os";
+import { isAbsolute as isAbsolute3, join as join3, resolve as resolve3 } from "node:path";
+var INBOX_DISCOVER_TIMEOUT_MS = 2000;
+var INBOX_SESSION_THREADS_TIMEOUT_MS = 1500;
+var INBOX_POLL_WAIT_MS = 20000;
+var INBOX_RETRY_MS = { first: 5000, max: 60000 };
+var INBOX_TICK_MS = 1000;
+var START_TIMEOUT_MS = 30000;
+var INBOX_LEASE_EVERY_MS = 5000;
+var INBOX_LEASE_STALE_MS = 20000;
+var INBOX_STATE_EVERY_TICKS = 5;
+var INBOX_INSTALL_TEXT = "The Plannotator Inbox is not running, and there is no plannotator command on this machine to start it: install Plannotator (https://plannotator.ai/docs/getting-started/installation/), then call again.";
+var INBOX_STILL_MISSING_TEXT = "The Plannotator Inbox is not running (no plannotator command on PATH).";
+function inboxRegistryFileOf(dataDir) {
+  return join3(dataDir, "inbox", "inbox.json");
+}
+function rememberedToolsFileOf(dataDir) {
+  return join3(dataDir, "inbox", "connection-tools.json");
+}
+function claimDirOf(dataDir, replyId, session) {
+  return join3(dataDir, "inbox", "claims", inboxClaimName(replyId, session));
+}
+function inboxLeaseFileOf(dataDir, host, sessionId) {
+  return join3(dataDir, "inbox", "leases", `${host}-${sessionId.replace(/[^A-Za-z0-9._-]/g, "_")}.json`);
+}
+function parseLease(text) {
+  try {
+    const value = JSON.parse(text ?? "");
+    if (typeof value.at !== "number")
+      return null;
+    return {
+      owner: typeof value.owner === "string" && value.owner ? value.owner : null,
+      at: value.at,
+      touchedAt: typeof value.touchedAt === "number" ? value.touchedAt : 0
+    };
+  } catch {
+    return null;
+  }
+}
+function readText(path) {
+  try {
+    return readFileSync2(path, "utf8");
+  } catch {
+    return null;
+  }
+}
+function readRegistry(dataDir) {
+  return parseInboxRegistry(readText(inboxRegistryFileOf(dataDir)));
+}
+function errorText(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+async function mcpCall(port, method, params, signal) {
+  const response = await fetch(`http://127.0.0.1:${port}/mcp`, {
+    method: "POST",
+    headers: { "content-type": "application/json", accept: "application/json, text/event-stream" },
+    body: JSON.stringify({ jsonrpc: "2.0", id: 1, method, params }),
+    signal
+  });
+  return mcpAnswerOfResponse(response.status, await response.text());
+}
+async function discoverInboxTools(dataDir, options = {}) {
+  if (!existsSync3(inboxRegistryFileOf(dataDir)))
+    return null;
+  const registry = readRegistry(dataDir);
+  if (registry) {
+    const answer = await mcpCall(registry.port, "tools/list", {}, AbortSignal.timeout(options.timeoutMs ?? INBOX_DISCOVER_TIMEOUT_MS)).catch(() => null);
+    const tools2 = answer && "result" in answer ? parseInboxToolList(answer.result) : [];
+    if (tools2.length > 0) {
+      try {
+        const file = rememberedToolsFileOf(dataDir);
+        writeFileSync2(`${file}.tmp`, JSON.stringify({ tools: tools2 }), { mode: 384 });
+        chmodSync(`${file}.tmp`, 384);
+        renameSync2(`${file}.tmp`, file);
+      } catch {}
+      return tools2;
+    }
+  }
+  let remembered = null;
+  try {
+    remembered = JSON.parse(readText(rememberedToolsFileOf(dataDir)) ?? "null");
+  } catch {
+    remembered = null;
+  }
+  const tools = parseInboxToolList(remembered);
+  return tools.length > 0 ? tools : null;
+}
+function inboxProjectDir(cwd, given) {
+  try {
+    const real = realpathSync2(isAbsolute3(given) ? given : resolve3(cwd, given));
+    return statSync2(real).isDirectory() ? real : null;
+  } catch {
+    return null;
+  }
+}
+
+class InboxAgentConnection {
+  options;
+  tools;
+  saidInstall = false;
+  constructor(options) {
+    this.options = options;
+    this.tools = options.tools;
+  }
+  get dataDir() {
+    return this.options.dataDir;
+  }
+  get host() {
+    return this.options.host;
+  }
+  async callTool(input, at) {
+    const call = inboxToolCall(input, this.tools, {
+      project_path: at.cwd,
+      agent_session: at.sessionId,
+      agent_host: this.options.host,
+      agent_name: this.options.agentName
+    });
+    if ("error" in call)
+      return { text: call.error, isError: true };
+    if (call.projectPath !== undefined) {
+      const resolved = inboxProjectDir(at.cwd, call.projectPath);
+      if (!resolved)
+        return { text: `Invalid plannotator_inbox call: project_path ${call.projectPath} is not an existing folder.`, isError: true };
+      call.arguments.project_path = resolved;
+    }
+    const running = await this.ensureRunning();
+    if ("error" in running)
+      return { text: running.error, isError: true };
+    let answer;
+    try {
+      answer = await mcpCall(running.port, "tools/call", inboxToolCallParams(call, { wakes: at.wakes === true }));
+    } catch (error) {
+      return { text: `The Plannotator Inbox did not answer (${errorText(error)}).`, isError: true };
+    }
+    if (!answer)
+      return { text: "The Plannotator Inbox gave an answer this session could not read.", isError: true };
+    if (answer.error) {
+      const message = answer.error.message ?? "unknown error";
+      if (/not found|unknown tool/i.test(message))
+        return { text: `This Plannotator Inbox has no ${call.name}; update Plannotator. (${message})`, isError: true };
+      return { text: `The Plannotator Inbox refused the call: ${message}`, isError: true };
+    }
+    return inboxToolResultText(answer.result);
+  }
+  async sessionThreads(at, toolName = INBOX_TOOL_NAME, timeoutMs = INBOX_SESSION_THREADS_TIMEOUT_MS) {
+    const registry = readRegistry(this.dataDir);
+    if (!registry || !at.sessionId || !at.cwd)
+      return null;
+    const signal = AbortSignal.timeout(timeoutMs);
+    try {
+      const health = await fetch(`http://127.0.0.1:${registry.port}/api/inbox/health`, { signal });
+      if (health.status !== 200 || !inboxHealthPeeks(await health.json(), registry.serverSession))
+        return null;
+      const answer = await mcpCall(registry.port, "tools/call", inboxSessionThreadsParams(at.cwd, at.sessionId), signal);
+      if (!answer || !("result" in answer))
+        return null;
+      const result = answer.result;
+      return result?.isError === true ? null : inboxSessionThreadsText(result, toolName);
+    } catch {
+      return null;
+    }
+  }
+  async isRunning(registry) {
+    try {
+      const response = await fetch(`http://127.0.0.1:${registry.port}/api/inbox/health`, { signal: AbortSignal.timeout(5000) });
+      if (response.status !== 200)
+        return false;
+      return (await response.json()).serverSession === registry.serverSession;
+    } catch {
+      return false;
+    }
+  }
+  async ensureRunning() {
+    const known = readRegistry(this.dataDir);
+    if (known && await this.isRunning(known))
+      return known;
+    const started = await this.startInbox();
+    if (started.missing) {
+      const text = this.saidInstall ? INBOX_STILL_MISSING_TEXT : INBOX_INSTALL_TEXT;
+      this.saidInstall = true;
+      return { error: text };
+    }
+    if (started.exitCode !== 0) {
+      const why = started.output.trim() || `exit ${started.exitCode}`;
+      if (/unknown command/i.test(why))
+        return { error: "The plannotator on PATH has no Inbox (an older version); update Plannotator." };
+      return { error: `The Plannotator Inbox did not start: ${why}` };
+    }
+    return readRegistry(this.dataDir) ?? { error: "The Plannotator Inbox started but wrote no registry." };
+  }
+  async startInbox() {
+    for (const command of plannotatorCommands(this.options.command)) {
+      const run = await runOnce(command, ["inbox", "--background"], { ...process.env, PLANNOTATOR_DATA_DIR: this.dataDir });
+      if (!run.missing)
+        return run;
+    }
+    return { missing: true, exitCode: null, output: "" };
+  }
+  async bridge(path, session, body, signal) {
+    const registry = readRegistry(this.dataDir);
+    if (!registry)
+      return null;
+    try {
+      const response = await fetch(`http://127.0.0.1:${registry.port}${path}`, {
+        method: "POST",
+        headers: { "content-type": "application/json", authorization: `Bearer ${registry.token}` },
+        body: JSON.stringify({ session, host: this.options.host, ...body }),
+        signal
+      });
+      return { status: response.status, text: await response.text() };
+    } catch {
+      return null;
+    }
+  }
+}
+function runOnce(command, args, env) {
+  return new Promise((resolve4) => {
+    let output = "";
+    let stdout = "";
+    let stderr = "";
+    let settled = false;
+    const done = (value) => {
+      if (settled)
+        return;
+      settled = true;
+      clearTimeout(timer);
+      resolve4(value);
+    };
+    let child;
+    try {
+      child = spawn(command, args, { env, stdio: ["ignore", "pipe", "pipe"], windowsHide: true });
+    } catch (error) {
+      resolve4({ missing: error.code === "ENOENT", exitCode: null, output: errorText(error) });
+      return;
+    }
+    const timer = setTimeout(() => {
+      child.kill();
+      done({ missing: false, exitCode: null, output: `${output}
+(no answer within ${START_TIMEOUT_MS / 1000} s)` });
+    }, START_TIMEOUT_MS);
+    child.stdout?.on("data", (chunk) => {
+      output += String(chunk);
+      stdout += String(chunk);
+    });
+    child.stderr?.on("data", (chunk) => {
+      output += String(chunk);
+      stderr += String(chunk);
+    });
+    child.on("error", (error) => done({ missing: error.code === "ENOENT", exitCode: null, output: error.message }));
+    child.on("close", (code) => done({ missing: false, exitCode: code, output, stdout, stderr }));
+  });
+}
+function plannotatorCommands(command) {
+  if (command)
+    return [command];
+  const bin = process.env.PLANNOTATOR_BIN?.trim();
+  return bin ? [bin] : ["plannotator", join3(homedir2(), ".local", "bin", "plannotator")];
+}
+class InboxDeliverLater extends Error {
+  deliverLater = true;
+}
+function isInboxDeliverLater(error) {
+  return error instanceof InboxDeliverLater || typeof error === "object" && error !== null && error.deliverLater === true;
+}
+
+class InboxWake {
+  connection;
+  sessionId;
+  target;
+  tickMs;
+  timer = null;
+  disposed = false;
+  ticking = false;
+  polling = false;
+  delivering = false;
+  retryAt = 0;
+  backoffMs = 0;
+  idleTicks = 0;
+  abort = new AbortController;
+  pending = new Map;
+  noSteer = new Set;
+  settled = new Set;
+  unacked = new Set;
+  instanceId = randomUUID();
+  leaseFile;
+  leader = false;
+  leaseCheckedAt = Number.NEGATIVE_INFINITY;
+  touchedAt = 0;
+  startedAt = Date.now();
+  lastLabel = "";
+  busy = null;
+  idleSince = null;
+  stateCheckedAt = Number.NEGATIVE_INFINITY;
+  lastSteerable = null;
+  constructor(connection, sessionId, target, tickMs = INBOX_TICK_MS) {
+    this.connection = connection;
+    this.sessionId = sessionId;
+    this.target = target;
+    this.tickMs = tickMs;
+    this.leaseFile = inboxLeaseFileOf(connection.dataDir, connection.host, sessionId);
+  }
+  get isDisposed() {
+    return this.disposed;
+  }
+  start() {
+    if (this.timer || this.disposed)
+      return;
+    this.touch();
+    this.timer = setInterval(() => {
+      if (this.ticking)
+        return;
+      this.ticking = true;
+      this.tick().catch(() => {
+        return;
+      }).finally(() => {
+        this.ticking = false;
+      });
+    }, this.tickMs);
+    this.timer.unref?.();
+  }
+  dispose() {
+    if (this.disposed)
+      return;
+    this.disposed = true;
+    if (this.timer)
+      clearInterval(this.timer);
+    this.timer = null;
+    this.abort.abort();
+    if (this.leader)
+      writeLease(this.leaseFile, { owner: null, at: 0, touchedAt: 0 });
+    this.leader = false;
+  }
+  touch() {
+    this.touchedAt = Date.now();
+    if (!this.disposed)
+      this.holdLease(this.touchedAt);
+  }
+  holdLease(now) {
+    this.leaseCheckedAt = now;
+    const lease = parseLease(readText(this.leaseFile));
+    const foreign = !!lease?.owner && lease.owner !== this.instanceId && Math.abs(now - lease.at) < INBOX_LEASE_STALE_MS;
+    if (foreign && lease && lease.touchedAt >= this.touchedAt) {
+      this.leader = false;
+      return false;
+    }
+    writeLease(this.leaseFile, { owner: this.instanceId, at: now, touchedAt: this.touchedAt });
+    this.leader = true;
+    return true;
+  }
+  onForeignPrompt() {
+    this.idleTicks = 0;
+  }
+  async tick() {
+    if (this.disposed)
+      return;
+    let busy = null;
+    const asked = Date.now();
+    if (this.pending.size > 0 || asked - this.stateCheckedAt >= this.tickMs * INBOX_STATE_EVERY_TICKS) {
+      this.stateCheckedAt = asked;
+      busy = await this.target.isBusy();
+      this.noteBusy(busy, asked);
+    }
+    this.idleTicks = this.pending.size === 0 || busy !== false ? 0 : this.idleTicks + 1;
+    for (const id of [...this.unacked])
+      await this.acknowledge(id);
+    const now = Date.now();
+    if (now - this.leaseCheckedAt >= INBOX_LEASE_EVERY_MS)
+      this.holdLease(now);
+    if (!this.leader)
+      return;
+    if (!this.polling && now >= this.retryAt)
+      this.poll();
+    const urgent = [...this.pending.values()].some((command) => command.now === true && !this.noSteer.has(command.id)) && (this.steerable || busy === false);
+    if (!this.delivering && this.pending.size > 0 && (this.idleTicks >= 2 || urgent)) {
+      this.delivering = true;
+      this.deliverNext(this.idleTicks < 2 && urgent).catch(() => {
+        return;
+      }).finally(() => {
+        this.delivering = false;
+      });
+    }
+  }
+  get steerable() {
+    return typeof this.target.steer === "function" && (this.target.canSteer?.() ?? true);
+  }
+  noteBusy(busy, now) {
+    const steerable = this.steerable;
+    if (busy === this.busy && steerable === this.lastSteerable)
+      return;
+    const known = this.busy !== null;
+    if (busy !== this.busy && !busy)
+      this.idleSince = now;
+    this.busy = busy;
+    this.lastSteerable = steerable;
+    if (known && this.leader && !this.disposed) {
+      this.connection.bridge(INBOX_BRIDGE_EVENT_PATH, this.sessionId, { type: "state", busy, idle_since: this.idleSince, [INBOX_SEND_NOW_POLL_FIELD]: steerable }).catch(() => null);
+    }
+  }
+  async pendingNow(waitMs) {
+    const signal = AbortSignal.any([this.abort.signal, AbortSignal.timeout(waitMs + 1e4)]);
+    let projectPath = null;
+    try {
+      projectPath = await this.target.projectPath?.();
+    } catch {
+      projectPath = null;
+    }
+    try {
+      const label = await this.target.label?.();
+      if (typeof label === "string")
+        this.lastLabel = label;
+    } catch {}
+    let plugin = null;
+    try {
+      plugin = this.target.plugin?.() ?? null;
+      if (!plugin) {
+        const version = this.target.pluginVersion?.() ?? null;
+        plugin = version ? { version } : null;
+      }
+    } catch {
+      plugin = null;
+    }
+    const response = await this.connection.bridge(INBOX_BRIDGE_POLL_PATH, this.sessionId, {
+      waitMs,
+      ...typeof projectPath === "string" && projectPath ? { project_path: projectPath } : {},
+      ...this.target.label ? { label: this.lastLabel } : {},
+      started_at: this.startedAt,
+      ...this.busy === null ? {} : { busy: this.busy, idle_since: this.idleSince },
+      ...this.steerable ? { [INBOX_SEND_NOW_POLL_FIELD]: true } : {},
+      [INBOX_STEER_POLLS_POLL_FIELD]: true,
+      [INBOX_TAGS_POLL_FIELD]: true,
+      ...plugin?.version ? { plugin } : {}
+    }, signal);
+    return response && response.status === 200 ? parseInboxBridgeCommands(response.text) : null;
+  }
+  async poll() {
+    this.polling = true;
+    try {
+      const commands = await this.pendingNow(INBOX_POLL_WAIT_MS);
+      if (this.disposed)
+        return;
+      if (commands === null) {
+        this.backoffMs = this.backoffMs ? Math.min(this.backoffMs * 2, INBOX_RETRY_MS.max) : INBOX_RETRY_MS.first;
+        this.retryAt = Date.now() + this.backoffMs;
+        return;
+      }
+      this.backoffMs = 0;
+      this.retryAt = 0;
+      const handedOut = new Set(commands.map((command) => command.id));
+      for (const id of this.settled)
+        if (!handedOut.has(id))
+          this.settled.delete(id);
+      for (const command of commands) {
+        if (!this.settled.has(command.id))
+          this.pending.set(command.id, command);
+      }
+    } finally {
+      this.polling = false;
+    }
+  }
+  settle(id) {
+    this.pending.delete(id);
+    this.settled.add(id);
+  }
+  async deliverNext(urgent = false) {
+    const waiting = this.pending.values().next().value;
+    if (!waiting)
+      return;
+    const fresh = await this.pendingNow(0);
+    if (fresh === null || this.disposed)
+      return;
+    const command = fresh.find((candidate) => candidate.id === waiting.id);
+    if (!command) {
+      this.pending.delete(waiting.id);
+      return;
+    }
+    const busy = await this.target.isBusy();
+    const steering = busy && urgent && this.steerable;
+    if (busy && !steering) {
+      this.idleTicks = 0;
+      return;
+    }
+    if (this.disposed || !this.holdLease(Date.now()))
+      return;
+    if (!command.tagged && existsSync3(join3(this.connection.dataDir, "inbox", "claims", command.id))) {
+      this.settle(command.id);
+      return;
+    }
+    const claim = claimDirOf(this.connection.dataDir, command.id, this.sessionId);
+    try {
+      mkdirSync2(join3(claim, ".."), { recursive: true, mode: 448 });
+      mkdirSync2(claim, { mode: 448 });
+    } catch (error) {
+      if (error.code === "EEXIST")
+        this.settle(command.id);
+      return;
+    }
+    writeQuietly(join3(claim, "by"), this.instanceId);
+    writeQuietly(join3(claim, "pid"), String(process.pid));
+    if (steering) {
+      try {
+        await this.target.steer(inboxWakeText(command), command);
+      } catch {
+        try {
+          rmSync(claim, { recursive: true, force: true });
+        } catch {}
+        this.noSteer.add(command.id);
+        this.connection.bridge(INBOX_BRIDGE_EVENT_PATH, this.sessionId, { type: "send_now_failed", id: command.id }).catch(() => null);
+        return;
+      }
+      writeQuietly(join3(claim, "delivered"), new Date().toISOString());
+      this.settle(command.id);
+      this.unacked.add(command.id);
+      await this.acknowledge(command.id);
+      return;
+    }
+    try {
+      await this.target.deliver(inboxWakeText(command), command);
+    } catch (error) {
+      if (isInboxDeliverLater(error)) {
+        try {
+          rmSync(claim, { recursive: true, force: true });
+        } catch {}
+        return;
+      }
+      this.settle(command.id);
+      writeQuietly(join3(claim, "reported"), "1");
+      this.target.notify(`A reply in the Plannotator Inbox (${command.subject ?? "a thread"}) could not be delivered to this session (${errorText(error)}). Read it in the Inbox: ${command.url}`);
+      return;
+    }
+    writeQuietly(join3(claim, "delivered"), new Date().toISOString());
+    this.settle(command.id);
+    this.unacked.add(command.id);
+    await this.acknowledge(command.id);
+  }
+  async acknowledge(id) {
+    const response = await this.connection.bridge(INBOX_BRIDGE_EVENT_PATH, this.sessionId, { type: "delivered", id });
+    if (!response)
+      return;
+    if (response.status === 200 || response.status >= 400 && response.status < 500 && response.status !== 401)
+      this.unacked.delete(id);
+  }
+}
+function writeLease(file, lease) {
+  try {
+    mkdirSync2(join3(file, ".."), { recursive: true, mode: 448 });
+    const tmp = `${file}.${process.pid}.tmp`;
+    writeFileSync2(tmp, JSON.stringify(lease), { mode: 384 });
+    renameSync2(tmp, file);
+  } catch {}
+}
+function writeQuietly(path, text) {
+  try {
+    writeFileSync2(path, text, { mode: 384 });
+  } catch {}
+}
+
+// inbox.ts
+var CLINE_INBOX_HOST = "cline";
+var CLINE_INBOX_AGENT_NAME = "Cline";
+var CLINE_DELIVERY_WAIT_MS = 15000;
+var CLINE_DISCOVER_TIMEOUT_MS = 750;
+var CLINE_TOOL_TIMEOUT_MS = 120000;
+function say(ctx, message) {
+  try {
+    (ctx.logger?.warn ?? ctx.logger?.log)?.(`plannotator: ${message}`);
+  } catch {}
+}
+
+class ClineInboxSession {
+  connection;
+  sessionId;
+  ctx;
+  deps;
+  wake;
+  runs = new Set;
+  waiting = [];
+  disposed = false;
+  constructor(connection, sessionId, ctx, deps) {
+    this.connection = connection;
+    this.sessionId = sessionId;
+    this.ctx = ctx;
+    this.deps = deps;
+    this.wake = new InboxWake(connection, sessionId, this.target(), deps.tickMs);
+  }
+  target() {
+    return {
+      isBusy: () => this.runs.size > 0 || this.waiting.length > 0,
+      deliver: (text, _command) => this.put(text),
+      notify: (message) => say(this.ctx, message),
+      projectPath: () => this.ctx.cwd ?? this.ctx.workspaceInfo?.rootPath ?? null,
+      pluginVersion: () => this.deps.version ?? null
+    };
+  }
+  put(text) {
+    const emit = this.ctx.emitEvent;
+    if (this.disposed || typeof emit !== "function")
+      return Promise.reject(new Error("this Cline session cannot take a prompt from a plugin"));
+    const waitMs = this.deps.deliveryWaitMs ?? CLINE_DELIVERY_WAIT_MS;
+    return new Promise((resolve4, reject) => {
+      let timer;
+      const settle = (error) => {
+        clearTimeout(timer);
+        const at = this.waiting.indexOf(entry);
+        if (at < 0)
+          return;
+        this.waiting.splice(at, 1);
+        if (error)
+          reject(error);
+        else
+          resolve4();
+      };
+      const entry = {
+        done: () => settle(),
+        later: (why) => settle(new InboxDeliverLater(why)),
+        rearm: () => {
+          clearTimeout(timer);
+          timer = setTimeout(() => entry.later("no Cline run took it"), waitMs);
+          timer.unref?.();
+        }
+      };
+      this.waiting.push(entry);
+      entry.rearm();
+      try {
+        emit("queue_message", { prompt: text });
+      } catch (error) {
+        settle(error instanceof Error ? error : new Error(String(error)));
+      }
+    });
+  }
+  start() {
+    this.wake.start();
+  }
+  beforeRun(context) {
+    const fresh = this.runs.size === 0;
+    this.runs.add(context?.snapshot?.agentId ?? "run");
+    if (!fresh)
+      return;
+    const ours = this.waiting[0];
+    if (ours) {
+      ours.done();
+      return;
+    }
+    this.wake.onForeignPrompt();
+    this.wake.touch();
+  }
+  afterRun(context) {
+    const key = context?.snapshot?.agentId ?? "run";
+    if (this.runs.delete(key) || key !== "run" && this.runs.delete("run"))
+      return;
+    for (const entry of this.waiting)
+      entry.rearm();
+  }
+  touch() {
+    this.wake.touch();
+  }
+  dispose() {
+    if (this.disposed)
+      return;
+    this.disposed = true;
+    this.wake.dispose();
+    for (const entry of [...this.waiting])
+      entry.later("the Cline session closed before a run took it");
+  }
+}
+async function setupClineInbox(api, ctx, deps = {}) {
+  const sessionId = ctx.session?.sessionId;
+  if (typeof sessionId !== "string" || !sessionId)
+    return null;
+  const env = deps.env ?? process.env;
+  if (!resolveInboxTool(loadConfig(), env, CLINE_INBOX_HOST))
+    return null;
+  const dataDir = deps.dataDir ?? getPlannotatorDataDir();
+  if (!existsSync4(inboxRegistryFileOf(dataDir)))
+    return null;
+  const tools = await (deps.discover ?? ((dir) => discoverInboxTools(dir, { timeoutMs: CLINE_DISCOVER_TIMEOUT_MS })))(dataDir).catch(() => null);
+  if (!tools)
+    return null;
+  const connection = new InboxAgentConnection({ dataDir, host: CLINE_INBOX_HOST, agentName: CLINE_INBOX_AGENT_NAME, tools });
+  const session = new ClineInboxSession(connection, sessionId, ctx, deps);
+  const spec = inboxAgentTool(connection.tools);
+  if (spec && typeof api.registerTool === "function") {
+    try {
+      api.registerTool({
+        name: spec.name,
+        description: spec.description,
+        inputSchema: spec.inputSchema,
+        timeoutMs: CLINE_TOOL_TIMEOUT_MS,
+        retryable: false,
+        maxRetries: 0,
+        async execute(input) {
+          session.touch();
+          const cwd = ctx.cwd ?? ctx.workspaceInfo?.rootPath ?? process.cwd();
+          const result = await connection.callTool(input, { sessionId, cwd, wakes: true });
+          if (result.isError)
+            throw new Error(result.text);
+          return result.text;
+        }
+      });
+    } catch (error) {
+      say(ctx, `could not register plannotator_inbox (${error instanceof Error ? error.message : String(error)}); replies still wake this session`);
+    }
+  }
+  ctx.onDispose?.(() => session.dispose());
+  session.start();
+  return session;
+}
+
+// index.ts
+function readPluginVersion() {
+  let here;
+  try {
+    here = dirname(fileURLToPath(import.meta.url));
+  } catch {
+    return null;
+  }
+  for (const candidate of [join4(here, "package.json"), join4(here, "..", "package.json")]) {
+    try {
+      const pkg = JSON.parse(readFileSync3(candidate, "utf8"));
+      if (pkg.name === "@plannotator/cline" && typeof pkg.version === "string" && pkg.version)
+        return pkg.version;
+    } catch {}
+  }
+  return null;
+}
+var session = null;
+var plugin = {
+  name: "plannotator",
+  manifest: { capabilities: ["tools", "hooks"] },
+  async setup(api, ctx) {
+    try {
+      session?.dispose();
+      session = await setupClineInbox(api, ctx, { version: readPluginVersion() });
+    } catch (error) {
+      session = null;
+      try {
+        ctx.logger?.warn?.(`plannotator: the Inbox connection did not start (${error instanceof Error ? error.message : String(error)})`);
+      } catch {}
+    }
+  },
+  hooks: {
+    beforeRun(context) {
+      try {
+        session?.beforeRun(context);
+      } catch {}
+      return;
+    },
+    afterRun(context) {
+      try {
+        session?.afterRun(context);
+      } catch {}
+    }
+  }
+};
+var cline_plugin_default = plugin;
+export {
+  plugin,
+  cline_plugin_default as default
+};