@uuaid/pillar 0.2.0-alpha.10

package/INTERACTION-CONVENTION.md

@@ -0,0 +1,44 @@
+# Pillar Interaction Convention v1
+
+App-layer standard for bidirectional interactive conversations over the
+pillar carrier (v0.2.0-alpha.5). No core protocol changes — this is a
+convention any enrolled agent opts into by mutual agreement. LLM-agnostic:
+pure JSON envelopes; any client that can HTTPS + Ed25519-seal can speak it.
+
+## Kinds
+
+| kind      | semantics                                              |
+|-----------|--------------------------------------------------------|
+| `request` | expects exactly one `reply`; its envelope id = thread root |
+| `reply`   | answers a `request`; MUST carry `thread` + `inReplyTo` |
+| `ack`     | receipt for any envelope; echoes the id being acked    |
+| `message` | fire-and-forget (default kind, unchanged)              |
+
+## Payload fields (all optional unless stated)
+
+- `text` — human/agent-readable body
+- `thread` — id of the thread-root `request` envelope (REQUIRED on `reply`)
+- `inReplyTo` — id of the envelope being answered (REQUIRED on `reply`/`ack`)
+- `status` — on `reply`: `"ok"` | `"error"`; on error add `reason`
+- `acks` — no receipt field needed; the `ack` envelope IS the receipt
+  (carrier limitation #5: receipts are app-layer by design)
+
+## Rules
+
+1. Thread root = the first `request`'s envelope id (known to recipient from
+   the envelope itself; the request payload needs no thread field).
+2. Every `request` and `reply` SHOULD be acked within 30s. Absence of an
+   ack = retry (idempotent — carrier dedups on envelope id), not failure.
+3. Multi-turn: same `thread` for the whole conversation, `inReplyTo` =
+   the latest envelope id each time.
+4. Errors ride the normal channel: `kind: "reply", status: "error",
+   reason: "<why>"` — never a different side-channel.
+5. `kind` stays non-sensitive (visible to carrier); anything sensitive goes
+   inside the sealed payload.
+
+## Interactive helper
+
+`bin/pillar-ask.mjs <recipient-uuaid> '<question>' [--to-pubkey HEX]`
+sends a `request` and blocks until the `ack`+`reply` arrive (default
+120s timeout), printing: request id → ack latency → reply latency → text.
+Synchronous Q→A over the same carrier as everything else.

package/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

package/README.md

@@ -0,0 +1,114 @@
+# @uuaid/pillar
+
+**Pillar** — **P**rotocol for **I**nter-agent **L**inked **L**edger **A**nd
+**R**elay — is the secure delivery layer of **UACP**, the Universal Agent
+Communication Protocol:
+
+> **UACP = UUAID (who) + Envelope (what) + Pillar (how it moves).**
+
+UUAID handles identity, discovery, keys, and resolution. The Envelope is the
+canonical signed, encrypted message container. Pillar moves it: encrypted
+relay, chain-hashed mailbox ledger, routing, and store-and-forward transport.
+
+Every agent mints its own identity (UUAID + keypair) with one command, then
+exchanges encrypted, signed envelopes through the pillar network — a
+store-and-forward carrier mesh with a LimeWire/BitTorrent-style seed topology:
+no single carrier is the only store.
+
+**Minimal requirements:** Node.js >= 20, outbound HTTPS. That's it. Carrier
+mode needs no inbound ports, no daemon, no account. One identity = one
+keychain file + one SQLite mailbox.
+
+## Install
+
+```sh
+npm install -g @uuaid/pillar        # global bins: pillar, pillar-carrier, pillar-ask, pillar-responder, pillar-seed
+# or per-project:
+npm install @uuaid/pillar           # then npx pillar ... / npx pillar-ask ...
+```
+
+## Quick start — become an addressable agent in 3 commands
+
+```sh
+# 1. Mint an identity and wire the carrier mesh from the public directory
+pillar init --directory https://pillar.uuaid.org/directory.json
+#    -> prints your uuaid:... and publicKey
+
+# 2. See who you are
+pillar id
+
+# 3. Ask another agent a question (blocks for their ack + reply)
+pillar ask <their-uuaid> "<your question>"
+```
+
+Check your mail any time — `pillar-ask` never drains your inbox, so replies
+and messages queue at the carrier until you pull them:
+
+```sh
+pillar inbox            # one-shot: fetch pending envelopes, print, exit
+pillar inbox --unread   # also print older stored-but-never-shown envelopes
+pillar inbox --notify 'osascript -e "display notification ..."'  # hook when mail waits
+```
+
+For automated checking, put `pillar inbox --notify <cmd>` on a cron/launchd
+interval — the hook gets `PILLAR_NEW` / `PILLAR_UNREAD` / `PILLAR_UUAID` env
+vars and a JSON summary on stdin, and only fires when there is mail.
+
+> **One home, one live consumer.** Never point `pillar inbox` (or `pillar-ask`)
+> at a home directory that a running `pillar-responder`/`pillar recv` daemon
+> owns. Carrier reads are non-destructive, but the shared mailbox is idempotent
+> on envelope id — whichever process appends an envelope first fires its
+> handlers, and the other sees a duplicate and stays silent. Concretely: a
+> drain can consume a request the responder then never acks (cursor advance),
+> and an ask from a daemon-owned home can time out even though the reply
+> arrived (the daemon appended it first). Give interactive tools their own
+> identity/home.
+
+`--directory` fetches the directory and configures every carrier + seed listed
+there, and writes every `agents[]` entry (uuaid + publicKey) into
+`<home>/fleet.json` as your address book — so step 3 works immediately, no key
+exchange needed. For peers outside any directory, pass their key once with
+`pillar ask <uuaid> "..." --to-pubkey HEX`. Point it at your own directory.json
+to build a private mesh.
+
+## The three always-on roles
+
+| Bin | What it runs | Ongoing requirements |
+|---|---|---|
+| `pillar-responder` | Always-on auto-attendant: acks requests instantly, replies from fixed text or a command hook. Run it as a service; agents anywhere get ack+reply without you being live. | one process, outbound HTTPS |
+| `pillar-seed` | A carrier seed — makes you part of the p2p mesh. Any agent that lists your URL replicates every envelope to you and polls you in parallel with other seeds. | one process, one SQLite file, TLS-terminating proxy in front |
+| `pillar` | The full CLI (`init`, `id`, `send`, `send-group`, `recv`, `inbox`, `peers`) — optional libp2p DHT, or carrier-only. | only when used interactively |
+
+```sh
+pillar-responder --home ~/.pillar-responder --reply-text "ack" &
+pillar-seed --port 8799 --db /var/lib/pillar/seed.db &   # loopback by default
+```
+
+## Seed topology — how messages survive
+
+On send, `deliver()` replicates the envelope to **every** carrier in your set
+in parallel — any one accepting it is success. On receive, you poll **all** of
+them; duplicates across seeds are deduped by envelope id, so handlers fire
+exactly once. Kill any single seed and delivery continues through the
+survivors. To join the mesh as a seed: TLS-terminate a public URL and list it
+in a directory.json:
+
+```json
+{ "url": "https://your-host", "operator": "you", "region": "eu", "since": "2026-08-20" }
+```
+
+`pillar init --directory <that-directory>` picks it up automatically.
+
+## Protocol
+
+Envelope v2 (`uuaid-pillar-envelope/2`): mandatory E2E
+(x25519-hkdf-sha256-aes256gcm) when a recipient key is known, JCS-canonical
+Ed25519 transport signature. Carrier API: `/carrier/v1` (POST
+`/v1/envelopes`, GET `/v1/inbox/<uuaid>` long-poll, GET `/v1/health`).
+App-layer convention: kinds `request`/`reply`/`ack`/`message` (see
+INTERACTION-CONVENTION.md). Directory:
+`https://pillar.uuaid.org/directory.json` (protocol, carrier, agents, seeds).
+
+## License
+
+Apache-2.0.

package/bin/carrier.mjs

@@ -0,0 +1,51 @@
+#!/usr/bin/env node
+/**
+ * carrier — run a standalone carrier server (the 24/7 post office).
+ *
+ *   carrier --port 8799 --host 127.0.0.1 --db /opt/pillar-carrier/carrier.db
+ *
+ * Defaults to loopback (RedTeam F5) — expose only behind a TLS-terminating
+ * proxy (nginx/Caddy).  Pass --host 0.0.0.0 deliberately only if the carrier
+ * must terminate TLS itself.  One carrier serves any number of agents; agents
+ * authenticate per-request with their own keys.  No accounts, no state
+ * about who exists — pure store-and-forward.
+ */
+import { CarrierServer } from "../src/net/carrier-server.mjs";
+
+function parseArgs(argv) {
+  const args = {};
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i];
+    if (a.startsWith("--")) {
+      const k = a.slice(2);
+      args[k] = (argv[i + 1] && !argv[i + 1].startsWith("--")) ? argv[++i] : true;
+    }
+  }
+  return args;
+}
+
+const args = parseArgs(process.argv.slice(2));
+const port = Number(args.port ?? process.env.CARRIER_PORT ?? 8799);
+const host = args.host ?? process.env.CARRIER_HOST ?? "127.0.0.1";
+const dbPath = args.db ?? process.env.CARRIER_DB ?? "carrier.db";
+const ttlDays = Number(args.ttl ?? process.env.CARRIER_TTL_DAYS ?? 14);
+
+const server = new CarrierServer({ dbPath, ttlDays });
+const addr = await server.listen(port, host);
+console.log(`carrier listening on ${addr.address}:${addr.port}`);
+console.log(`  db:  ${dbPath}`);
+console.log(`  ttl: ${ttlDays} days`);
+
+// Vacuum expired envelopes hourly.
+const vacuumTimer = setInterval(() => {
+  const n = server.vacuum();
+  if (n > 0) console.log(`vacuumed ${n} expired envelopes`);
+}, 3600_000);
+
+const shutdown = async () => {
+  clearInterval(vacuumTimer);
+  await server.close();
+  process.exit(0);
+};
+process.on("SIGINT", shutdown);
+process.on("SIGTERM", shutdown);

package/bin/pillar-ask.mjs

@@ -0,0 +1,128 @@
+#!/usr/bin/env node
+/**
+ * pillar-ask — synchronous interactive Q→A over the pillar carrier.
+ *
+ *   pillar-ask <recipient-uuaid> '<question>' [--to-pubkey HEX] [--home DIR]
+ *              [--fleet FLEET.json] [--timeout SECONDS] [--kind request]
+ *
+ * Sends a `request` envelope (its id becomes the thread root) and blocks
+ * until the recipient's `ack` + `reply` arrive, printing latency for each.
+ * Exits 0 on reply(status ok), 3 on reply(status error), 4 on timeout.
+ * See INTERACTION-CONVENTION.md for the wire contract.
+ */
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { homedir } from "node:os";
+import { argv, exit } from "node:process";
+import { Keychain } from "../src/identity/keychain.mjs";
+import { Pillar } from "../src/pillar.mjs";
+import { loadFleetAddressBook } from "../src/address-book.mjs";
+
+function parseArgs(argv) {
+  const args = { _: [] };
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i];
+    if (a.startsWith("--")) {
+      const [k, ...rest] = a.slice(2).split("=");
+      args[k] = rest.length ? rest.join("=") : (argv[i + 1] && !argv[i + 1].startsWith("--") ? argv[++i] : true);
+    } else {
+      args._.push(a);
+    }
+  }
+  return args;
+}
+
+const args = parseArgs(argv.slice(2));
+const [recipient, question] = args._;
+if (!recipient || !question) {
+  console.error("usage: pillar-ask <recipient-uuaid> '<question>' [--to-pubkey HEX] [--home DIR] [--fleet FLEET.json] [--timeout S]");
+  exit(2);
+}
+
+const home = args.home || process.env.PILLAR_HOME || join(homedir(), ".pillar");
+const kcPath = join(home, "keychain.json");
+const mbPath = join(home, "mailbox.db");
+const cfgPath = join(home, "config.json");
+if (!existsSync(kcPath)) {
+  console.error(`no pillar found at ${home}. run: pillar init`);
+  exit(2);
+}
+const cfg = existsSync(cfgPath) ? JSON.parse(readFileSync(cfgPath, "utf-8")) : {};
+const kc = new Keychain(kcPath);
+kc.load({ passphrase: process.env.PILLAR_PASSPHRASE ?? "" });
+const carriers = args.carrier
+  ? [args.carrier]
+  : (process.env.PILLAR_CARRIERS ? process.env.PILLAR_CARRIERS.split(",") : (cfg.carriers ?? []));
+const p = new Pillar({
+  keychain: kc,
+  mailboxPath: mbPath,
+  listenAddrs: cfg.listenAddrs ?? ["/ip4/0.0.0.0/tcp/0", "/ip4/0.0.0.0/tcp/0/ws"],
+  bootstrapPeers: cfg.bootstrapPeers ?? [],
+  enableRelay: cfg.enableRelay ?? false,
+  dhtClientMode: cfg.dhtClientMode ?? true,
+  carriers,
+  enableLibp2p: !(cfg.carrierOnly === true),
+});
+
+const t0 = Date.now();
+const timeoutMs = (Number(args.timeout) || 120) * 1000;
+const kind = args.kind || "request";
+
+await p.start();
+if (p.carrierClient) p.startCarrierPolling(); // receive ack/reply from the carrier (p.start() does not poll)
+// Address book default: <home>/fleet.json (written by `pillar init --directory`
+// from the directory's agents[]) — so `pillar ask` works with no key plumbing.
+const fleetFile = args.fleet || join(home, "fleet.json");
+if (existsSync(fleetFile)) {
+  const n = loadFleetAddressBook(fleetFile, p);
+  if (n > 0) console.log(`address book: ${n} peers from ${fleetFile}`);
+}
+let envelopeId = null; // set after send; handlers may fire during start/send (carrier polling is live)
+const gotAck = new Promise((resolve) => p.onEnvelope((env) => {
+  if (env.kind === "ack" && envelopeId && env.payload?.inReplyTo === envelopeId) resolve(env);
+}));
+const gotReply = new Promise((resolve) => p.onEnvelope((env) => {
+  if (env.kind === "reply" && envelopeId && env.payload?.inReplyTo === envelopeId) resolve(env);
+}));
+
+const { envelope } = await p.send({
+  recipient,
+  recipientPublicKey: args["to-pubkey"] ?? undefined,
+  kind,
+  payload: { text: question },
+});
+envelopeId = envelope.id;
+console.log(`request ${envelopeId} sent to ${recipient} (kind=${kind})`);
+
+const waitFor = async (promise, label) => {
+  const winner = await Promise.race([
+    promise.then((env) => ({ env })),
+    new Promise((r) => setTimeout(() => r({ timeout: true }), timeoutMs)),
+  ]);
+  if (winner.timeout) {
+    console.error(`${label}: TIMEOUT after ${timeoutMs / 1000}s`);
+    exit(4);
+  }
+  const ms = Date.now() - t0;
+  console.log(`${label} from ${winner.env.sender} in ${ms}ms`);
+  return winner.env;
+};
+
+const ackEnv = await waitFor(gotAck, "ack");
+const replyEnv = await waitFor(gotReply, "reply");
+const status = replyEnv.payload?.status ?? "ok";
+if (status !== "ok") {
+  console.error(`reply status=${status} reason=${replyEnv.payload?.reason ?? "none"}`);
+  exit(3);
+}
+// Convention rule 2: the requester acks the reply it received (ack of ack would regress).
+await p.send({
+  recipient,
+  recipientPublicKey: args["to-pubkey"] ?? undefined,
+  kind: "ack",
+  payload: { inReplyTo: replyEnv.id },
+});
+console.log(`ack ${replyEnv.id} sent to ${recipient}`);
+console.log(replyEnv.payload?.text ?? "(empty reply)");
+await p.stop();
+exit(0);