agentcollar 0.0.1 → 0.2.0

package/dist/cli/intro-frames.js

@@ -0,0 +1,40 @@
+// GENERATED by tools/gen-intro.ts from brand/logo/agentcollar-mark-black.png. Do not edit by hand.
+// Derived from the AgentCollar mark: © 2026 ank8dev, all rights reserved (NOT covered by the MIT license).
+// The medallion, 48×48 dots (24 columns × 12 rows), turned 0°, 30°, … 330° clockwise.
+export const SPIN = [
+    ["", "       ⢀⣤⣤⣴⣶⣶⣶⣦⣄⡀", "     ⣤⣾⣵⣿⣿⣿⣿⣿⣿⣿⣿⣿⣷⣄", "   ⢠⣾⣿⣿⣿⠿⠻⣿⣿⣿⣿⣿⣿⣿⣿⣿⣷⡀", "  ⢀⣿⢻⣿⣿⡟ ⡀⠹⣿⣿⡿⠉⢀⡀⠘⣿⣿⣷⡀", "  ⢸⣿⣾⣿⡿ ⣸⣧ ⢻⣿⠁ ⣿⣿⣿⣿⣿⣿⡇", "  ⢸⣿⣿⣿⠃ ⣀⣀⡀⠈⣿ ⠘⣿⣿⡿⣿⣿⣿⡇", "  ⠈⣿⣿⡏ ⣼⣿⣿⣷ ⢸⣧⡀⠉⠉⢀⣼⣿⣿⠇", "   ⠘⣿⣷⣾⣿⣿⣿⣿⣷⣾⣿⣿⣶⣾⣿⡿⣻⠏", "     ⠻⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⠟⠁", "       ⠉⠛⠳⠶⠿⠿⠿⠟⠛⠁", ""],
+    ["", "       ⣀⣤⣴⣶⣒⣶⣶⣤⣄⣀", "    ⢀⣤⡾⢿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣷⣄", "   ⢠⣾⣯⣾⣿⣿⠿⠋⠉⢹⣿⣿⣿⣿⣿⣿⣷⡀", "  ⢀⣿⣿⣿⡿⠟⠁⣠⡆ ⣾⣿⣿⣿⣿⣿⣿⣿⣷", "  ⢸⣿⡿⠋ ⣀⡀⠉⠁⢀⣿⡿⠋⠉⣀⠉⢻⣿⣿⡆", "  ⢸⣿⣦⣤⣾⣿⣿⡇ ⣸⡏ ⣠⣾⣿⣤⣼⣿⣏⡇", "  ⠘⣿⣿⣿⣿⣿⣿⡇⢀⣿ ⢰⣿⣿⣿⣿⣿⣿⣿⠁", "   ⠘⣿⡿⣿⣿⣿⣿⣿⣿⣄ ⠉⠁⣹⣿⣿⣿⠃", "    ⠈⠻⢮⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⡿⠁", "       ⠈⠛⠻⠿⠿⠿⠿⠿⠚⠋⠁", ""],
+    ["", "       ⣀⣤⣤⣶⣶⣶⣶⣦⣤⡀", "    ⢀⣴⣾⣿⣿⣶⣶⣿⣿⣿⣿⣷⣾⣷⣄", "   ⢠⣿⣿⣿⡿⠿⠿⠛⠛⠛⠉⠛⣿⣿⣿⣿⣷⡄", "  ⢠⣿⣿⣀⣀⣀⣀ ⢲⡶⠋⢀⣾⣿⣿⣿⣿⣿⣷⡀", "  ⢸⣿⣿⣿⣿⣿⣿⡦  ⣴⣿⣿⣿⣿⣿⣿⣿⣿⡇", "  ⢸⡿⣿⣿⣿⣿⠋ ⣠⡾⠋⠉⠉⠁⠉⠻⣿⣿⣿⡇", "  ⠈⣷⣻⣿⣿⣿⣶⣿⠃⢀⣴⣾⣿⣿⡃⢠⣿⣿⡿", "   ⠈⢿⣿⣿⣿⣿⣿⡀⠘⠿⢿⣿⣿⣿⣿⣿⡿⠁", "     ⠻⢿⣿⣿⣿⣿⣶⣤⣼⣿⣿⣿⡿⠋", "       ⠉⠛⠿⢭⣿⣿⣿⠿⠛⠉", ""],
+    ["", "       ⣀⣤⣴⣶⣶⣶⣶⣦⣤⣀", "    ⢀⣤⣿⡿⠿⢿⣿⣿⣿⣷⣶⣿⣿⣷⣤", "   ⢠⣿⣿⣿⣷⣤⣀ ⠉⠙⠛⠿⣿⣿⣿⣿⡳⡀", "  ⢀⡿⣿⣿⣿⣿⣿⣿⡇ ⣷⠶⠄ ⢘⣿⣿⣿⣿", "  ⢸⣧⣿⣿⣿⡿⠛⠋⠁⢀⣀⣤⣴⣾⣿⣿⣿⣿⣿⡆", "  ⢸⣿⣿⣿⣿⣷⣶⠶⠛⠛⠛⠻⢿⣿⣿⣿⣿⣿⣿⡇", "  ⠈⣿⣿⣿⣿⡟⠁⢠⣤⣶⣤⣤⡀⠘⣿⣿⣿⣿⡿⠁", "   ⠈⣿⣿⣿⣷⡀⠘⢿⣿⣿⣿⠁⣀⣿⣿⣿⡿⠁", "    ⠈⠻⣝⣿⣿⣶⣿⣿⣿⣿⣿⣿⣿⡿⠋", "      ⠈⠙⠻⠿⠿⠿⠿⠿⠟⠋⠁", ""],
+    ["", "       ⣀⣤⣶⣶⣶⣶⣶⣦⣤⣀", "    ⢀⣴⢿⣿⣿⣿⣿⠁⠙⢿⣿⣿⣿⢷⣦", "   ⢀⣾⣵⣿⣿⣿⣿⣿⣷⡄ ⠹⣿⣿⣷⣹⣷⡄", "  ⢀⣿⣿⣿⣿⣿⠿⠿⠿⠿⠁⢠⣄⠈⢻⣿⣿⣿⣿⡀", "  ⢸⣿⣿⣿⣿⣿⣦⣤⣄⣀⡀⠈⠉⠁ ⢹⣿⣿⡟⡇", "  ⢸⣿⣿⣿⠋ ⣀⡀⠉⠙⢿⣿⣿⣷⣶⣾⣿⣿⣿⡇", "  ⠘⣟⣿⣿ ⠸⣿⣿⣷⣄ ⢹⣿⣿⣿⣿⣿⣿⡿", "   ⠹⣿⣿⣷⣾⣿⣿⣿⠛⠃⢠⣿⣿⣿⣿⣿⡿⠃", "    ⠙⠻⣿⣿⣿⣿⣿⣶⣶⣿⣿⣿⣿⡿⠋", "       ⠉⠛⠻⠯⠽⠿⠟⠛⠋⠁", ""],
+    ["", "       ⢀⣤⡴⢶⣶⣶⣶⣶⣤⣀", "    ⢀⣤⣾⣿⣷⣿⣿⣿⣿⣿⡟⠛⣿⣿⣦⡀", "   ⢠⣾⣿⣿⣿⣿⣿⣿⣿⣿⣿⡇ ⢿⣿⣿⣷⡄", "  ⢠⣿⣿⣿⣿⣿⣿⣧ ⠙⢿⠟⠃ ⢸⣿⣿⡟⣿", "  ⣾⣼⣿⡟⠁⣀⡀⠉⢷⣄  ⢶⡇ ⣿⣿⣧⣿⡇", "  ⣿⣿⣿⣀⣸⣿⣿⣆ ⢹⣿⣦⡀⠙ ⢻⣿⣿⣿⡇", "  ⠘⣿⣿⣿⣿⣿⣿⣿ ⠸⣿⣿⣿⣷⣤⣿⣿⡿⣿⠁", "   ⠘⢿⣿⣿⣿⣁⠉⢀⣼⣿⣿⣿⣿⣿⣿⣿⡷⠁", "     ⠙⢿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⡿⠋", "       ⠈⠙⠛⠿⠿⠿⠿⠟⠋⠉", ""],
+    ["", "       ⢀⣤⣴⣶⣶⣶⠶⢦⣤⣀", "    ⢀⣴⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣦", "   ⣰⣯⣾⣿⡿⠿⣿⣿⡿⢿⣿⣿⣿⣿⡿⢿⣿⡄", "  ⢰⣿⣿⡟⠁⣀⣀⠈⢻⡇ ⢿⣿⣿⡟ ⣸⣿⣿⡀", "  ⢸⣿⣿⣿⣾⣿⣿⡄ ⣿⡀⠈⠉⠉ ⢠⣿⣿⣿⡇", "  ⢸⣿⣿⣿⣿⣿⣿ ⢀⣿⣧ ⢻⡏ ⣾⣿⡿⣿⡇", "  ⠈⢿⣿⣿⡄⠈⠁⣀⣾⣿⣿⣆⠈ ⣼⣿⣿⣧⣿⠁", "   ⠈⢿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣦⣶⣿⣿⣿⡿⠃", "     ⠙⢿⣿⣿⣿⣿⣿⣿⣿⣿⣿⢟⡿⠛", "       ⠈⠙⠻⠿⠿⠿⠟⠛⠛⠁", ""],
+    ["", "      ⢀⣠⡤⣶⣶⣶⣶⣶⣦⣤⡀", "    ⢀⣾⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⡳⣦⡀", "   ⢠⣿⣿⣿⣏⢀⣀ ⠙⣿⣿⣿⣿⣿⣿⣾⣿⡄", "  ⢀⣿⣿⣿⣿⣿⣿⣿⠇ ⣿⠁⢸⣿⣿⣿⣿⣿⣿⡄", "  ⢸⣹⣿⡟⠛⣿⡿⠋ ⣸⡏ ⢸⣿⣿⡿⠛⠻⣿⡇", "  ⠸⣿⣿⣧⣀⠉⣀⣠⣾⣿⠁⢀⣀⠈⠉ ⣠⣾⣿⡇", "   ⢿⣿⣿⣿⣿⣿⣿⣿⡿ ⠸⠋⢀⣴⣾⣿⣿⣿⠁", "   ⠈⢿⣿⣿⣿⣿⣿⣿⣇⣀⣠⣶⣿⣿⡿⣻⡿⠃", "     ⠙⢿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣷⡾⠛⠁", "       ⠉⠙⠛⠿⠿⠭⠿⠟⠛⠉", ""],
+    ["", "       ⣀⣤⣶⣿⣿⣿⣓⣶⣤⣀", "     ⣠⣾⣿⣿⣿⡟⠛⠿⣿⣿⣿⣿⣷⣦", "   ⢀⣾⣿⣿⣿⣿⣿⣷⣶⡄⠈⣿⣿⣿⣿⣿⣷⡀", "   ⣾⣿⣿⠃⢨⣿⣿⡿⠟⠁⢠⣿⠿⣿⣿⣿⣯⢿⡀", "  ⢸⣿⣿⣿⣦⣀⢀⣀⣀⣠⡾⠋ ⣠⣿⣿⣿⣿⣾⡇", "  ⢸⣿⣿⣿⣿⣿⣿⣿⣿⠟  ⠺⣿⣿⣿⣿⣿⣿⡇", "  ⠈⢿⣿⣿⣿⣿⣿⡿⠁⣠⠾⠧ ⠉⠉⠉⠉⣿⣿⠃", "   ⠘⢿⣿⣿⣿⣿⣤⣀⣤⣤⣤⣶⣶⣾⣿⣿⣿⠃", "     ⠙⢿⡿⢿⣿⣿⣿⣿⠿⠿⣿⣿⡿⠟⠁", "       ⠈⠛⠻⠿⠿⠿⠿⠛⠛⠉", ""],
+    ["", "       ⢀⣠⣴⣶⣶⣶⣶⣶⣦⣄⡀", "     ⣠⣾⣿⣿⣿⣿⣿⣿⣿⠿⣿⣿⣝⣦⡀", "   ⢀⣾⣿⣿⣿⠉⢀⣿⣿⣿⣷⡄⠈⢿⣿⣿⣿⡀", "  ⢀⣾⣿⣿⣿⣿⡄⠈⠛⠛⠿⠛⠃⢀⣼⣿⣿⣿⣿⡀", "  ⢸⣿⣿⣿⣿⣿⣿⣷⣦⣤⣤⣤⠶⠿⢿⣿⣿⣿⣿⡇", "  ⠸⣿⣿⣿⣿⣿⡿⠟⠛⠉⠁⢀⣠⣤⣾⣿⣿⣿⢻⡇", "   ⣿⣿⣿⣿⡅ ⠐⠶⢿ ⢸⣿⣿⣿⣿⣿⣿⣾⠁", "   ⠈⢮⣿⣿⣿⣿⣶⣤⣄⣀ ⠉⠛⢿⣿⣿⣿⠃", "     ⠛⢿⣿⣿⠿⢿⣿⣿⣿⣷⣶⣾⣿⠛⠁", "       ⠉⠛⠻⠿⠿⠿⠿⠟⠛⠉", ""],
+    ["", "       ⢀⣠⣤⣴⣶⣖⣲⣦⣤⣀", "     ⣠⣾⣿⣿⣿⣿⠿⠿⣿⣿⣿⣿⣿⣦⣄", "   ⢠⣾⣿⣿⣿⣿⣿⠃⢠⣤⣿⣿⣿⡿⢿⣿⣿⣆", "   ⣾⣿⣿⣿⣿⣿⣿⣇ ⠙⢿⣿⣿⡆ ⣿⣿⣽⡄", "  ⢸⣿⣿⣿⡿⠿⢿⣿⣿⣷⣄⣀⠈⠉ ⣠⣿⣿⣿⡇", "  ⢸⣼⣿⣿⣇ ⢀⣀⡀⠈⠉⠙⠛⠻⣿⣿⣿⣿⣿⡇", "  ⠈⣿⣿⣿⣿⣧⡀⠙⠃⢀⣶⣶⣶⣶⣿⣿⣿⣿⣿⠁", "   ⠘⢿⣏⢿⣿⣿⣆ ⠘⢿⣿⣿⣿⣿⣿⢟⡿⠁", "     ⠻⢷⣿⣿⣿⣷⣄⢀⣿⣿⣿⣿⣷⠟⠁", "       ⠉⠛⠻⠿⠿⠿⠿⠿⠛⠉", ""],
+    ["", "       ⣀⣠⣴⣶⣶⣶⣶⣤⣄⡀", "     ⣠⣾⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣷⣄", "   ⢀⢾⣿⣿⣿⣿⣿⣿⣿⡟⠁⣀⢉⣿⣿⣿⣷⡄", "  ⢀⣿⣾⣿⣿⠛⢿⣿⣿⣿⡆ ⣿⣿⣿⣿⣿⣿⣿⡄", "  ⢸⣿⣿⣿⣧ ⣄⠈⠻⣿⣇ ⠹⣿⣿⡏⠉⣿⣿⣿", "  ⢸⣿⢻⣿⣿ ⢸⠷  ⠙⢷⣀⠈⠉⢀⣼⣿⡟⡿", "   ⣿⣼⣿⣿⡇ ⢠⣴⣷⣄ ⢻⣿⣿⣿⣿⣿⣿⠃", "   ⠘⢿⣿⣿⣷ ⢸⣿⣿⣿⣿⣿⣿⣿⣿⣿⡿⠃", "    ⠈⠻⣿⣿⣤⣼⣿⣿⣿⣿⣿⢿⣿⡿⠛⠁", "       ⠉⠛⠿⠿⠿⠿⠷⠞⠛⠁", ""],
+];
+// The same, 32×32 dots (16 columns × 8 rows), for narrow terminal windows.
+export const SPIN_SMALL = [
+    ["       ⢀⡀", "   ⢀⣴⣾⣿⣿⣿⣿⣷⣦⡀", "  ⣴⣿⣿⡟⠻⣿⣿⡿⠟⢿⣿⣆", " ⢠⣿⣿⡟⢠⡆⢹⡿ ⣶⣶⣿⣿⡄", " ⠘⣿⣿⠁⣠⣤ ⢧ ⠿⠟⣿⣿⡇", "  ⠹⣧⣴⣿⣿⣧⣼⣷⣤⣶⣿⡟", "   ⠙⠿⢿⣿⣿⣿⣿⣿⠟⠋", "       ⠉⠉"],
+    ["       ⣀⣀", "   ⢀⡴⣾⣿⣷⣿⣿⣷⣦⡀", "  ⣰⣿⣿⡿⠋⠉⣿⣿⣿⣿⣿⣆", " ⢰⣿⠟⠉⡀⠛ ⣿⠟⠛⠛⢿⣿⡀", " ⠸⣿⣶⣾⣿⠇⢸⠃⣰⣿⣷⣾⣿⠅", "  ⠻⣿⣿⣿⣶⣿⡀⠙⢛⣿⣿⡏", "   ⠉⠻⢿⣿⣿⣿⣿⣿⠿⠋", "       ⠉⠉⠁"],
+    ["       ⣀⣀", "   ⣀⣴⣿⣿⣽⣿⣿⣷⣦⡀", "  ⣴⡿⠟⠛⠛⣉⡉⢙⣿⣿⣿⣆", " ⢰⣿⣷⣶⣷⡄⠉⣰⣿⣿⣿⣿⣿⡀", " ⠸⣿⣿⣿⡋⣠⠞⢉⣀⣈⠙⣿⣿⠁", "  ⠹⣿⣿⣿⣇⠐⠿⣿⣷⣾⣿⠏", "   ⠈⠻⣿⣿⣷⣶⣿⣿⠟⠉", "      ⠈⠉⠉⠉"],
+    ["       ⣀⣀", "   ⣠⣴⠾⣿⣿⣿⣿⣿⣦⡀", "  ⣸⣿⣿⣦⣄⠈⣉⠛⠿⣿⣿⣆", " ⢠⣿⣿⣿⠿⠛ ⣉⣡⣴⣿⣿⣿⡀", " ⠘⣿⣿⣿⡶⠚⠉⠙⠛⢿⣿⣿⣿⠁", "  ⠻⣿⣿⡄⠸⣿⣿⡇⣨⣿⣿⠏", "   ⠙⠿⣿⣿⣿⣿⣿⡿⠟⠁", "      ⠉⠉⠉"],
+    ["      ⢀⣀⣀⡀", "   ⢠⣴⣿⣿⡟⠻⣿⣷⣦⡀", "  ⣰⣿⣿⣿⣿⣷⠄⠘⢿⣿⣽⣆", " ⢠⣿⣿⣿⣧⣈⣉ ⠛ ⢹⣿⡿⡄", " ⠸⣿⣿⠁⣠⣄⡉⠻⣿⣿⣿⣿⣿⠃", "  ⢻⣿⣦⣿⣿⡿ ⣿⣿⣿⣿⠏", "   ⠙⠿⢿⣿⣷⣾⣿⡿⠟⠁", "      ⠈⠈⠁"],
+    ["      ⢀⣀⣀⡀", "   ⢀⣴⣾⣿⣿⣿⡿⢿⣦⡄", "  ⣴⣿⣿⣿⠟⢿⣿⡧⠈⣿⣿⣦", " ⢰⣿⡿⠋⡉⠳⣄⠉⢠⡄⢻⣿⣻⡄", " ⢸⣿⣧⣼⣿⡆⠘⣷⣦⡁⣸⣿⣿⠃", "  ⠻⣿⣿⣏⠃⣰⣿⣿⣿⣿⣿⠏", "   ⠘⠻⢿⣿⣿⣿⣿⡿⠟⠁", "       ⠈⠁"],
+    ["       ⣀⣀", "   ⣠⣴⣿⣿⣿⣿⣿⣷⣶⣄", "  ⣼⣿⠿⠛⢿⡟⢻⣿⣿⠟⢻⣆", " ⢸⣿⣿⣴⣶ ⢳ ⠛⠋⢀⣿⣿⡄", " ⠘⣿⣿⠿⠿ ⣾⣇⠸⠃⣼⣿⣿⠃", "  ⠹⣿⣷⣴⣾⣿⣿⣦⣼⣿⣿⠟", "   ⠈⠻⢿⣿⣿⣿⣿⡿⠟⠁", "       ⠈⠁"],
+    ["      ⢀⣀⣀", "   ⣠⣶⣿⣿⣿⣿⣿⣷⣦⣀", "  ⣸⣿⣿⣥⣄⠈⣿⠿⣿⣿⣿⣦", " ⢐⣿⡿⢿⣿⠏⢠⡇⢰⣿⡿⠿⣿⡆", " ⠈⣿⣷⣤⣤⣴⣿ ⣤⠈⣀⣴⣿⠇", "  ⠹⣿⣿⣿⣿⣿⣀⣠⣾⣿⣿⠏", "   ⠈⠻⢿⣿⣿⢿⣿⡿⠞⠁", "       ⠉⠉"],
+    ["      ⣀⣀⣀⡀", "   ⣀⣴⣿⣿⠿⢿⣿⣿⣦⡀", "  ⣰⣿⡿⢿⣿⣶⠄⢹⣿⣿⣿⣆", " ⢀⣿⣿⣄⡉⠉⣁⡴⠋⣨⣿⣿⣿⡆", " ⠈⣿⣿⣿⣿⣿⠏⣀⠘⢿⠿⢿⣿⠇", "  ⠹⣿⣿⣿⣅⣈⣉⣤⣤⣴⣾⠟", "   ⠈⠻⢿⣿⣿⣟⣿⣿⠟⠉", "       ⠉⠉"],
+    ["       ⣀⣀⣀", "   ⢀⣴⣾⣿⣿⣿⣿⣿⣶⣄", "  ⣰⣿⣿⡋⢸⣿⣿⡆⠘⣿⣿⣦", " ⢀⣿⣿⣿⣷⣤⣄⣀⡤⠾⣿⣿⣿⡄", " ⠈⣿⣿⣿⠟⢋⣉ ⣤⣶⣿⣿⣿⠃", "  ⠹⣿⣿⣶⣤⣉⡀⠙⠻⣿⣿⡏", "   ⠈⠻⣿⣿⣿⣿⣿⡶⠟⠋", "       ⠉⠉"],
+    ["       ⢀⡀⡀", "   ⢀⣴⣾⣿⡿⢿⣿⣷⣶⣄", "  ⣰⣿⣿⣿⣿ ⣾⣿⣿⠻⣿⣧", " ⢠⣿⣿⣿⣿⣿⣦⣈⠙⠋⢀⣿⣿⡆", " ⠘⣾⣿⣇ ⣤ ⣉⡉⢻⣿⣿⣿⠃", "  ⠹⣟⣿⣷⡄⠐⢿⣿⣿⣿⣿⠏", "   ⠈⠻⢿⣿⣦⣼⣿⣿⠟⠃", "      ⠈⠉⠉⠁"],
+    ["       ⢀⡀", "   ⢀⣴⣾⣿⣿⣿⣿⣷⣦⡄", "  ⣰⣿⣿⣿⣿⣿⠏⢠⣹⣿⣿⣦", " ⢠⣿⣿⡏⢈⠻⢿⡄⠸⣿⡟⢻⣿⡇", " ⠘⣯⣿⣧⠘⠃⣀⠙⢦⣈⣠⣾⣿⠇", "  ⠻⣿⣿⡀⢺⣿⣷⣴⣿⣿⣿⠟", "   ⠘⠻⣷⣾⣿⣿⣿⡿⠟⠁", "      ⠈⠉⠉⠁"],
+];
+// Upright and smaller (32, 20, 12 dots): the medallion "flies" into the header.
+export const SHRINK = [
+    ["       ⢀⡀", "   ⢀⣴⣾⣿⣿⣿⣿⣷⣦⡀", "  ⣴⣿⣿⡟⠻⣿⣿⡿⠟⢿⣿⣆", " ⢠⣿⣿⡟⢠⡆⢹⡿ ⣶⣶⣿⣿⡄", " ⠘⣿⣿⠁⣠⣤ ⢧ ⠿⠟⣿⣿⡇", "  ⠹⣧⣴⣿⣿⣧⣼⣷⣤⣶⣿⡟", "   ⠙⠿⢿⣿⣿⣿⣿⣿⠟⠋", "       ⠉⠉"],
+    ["   ⣀⣤⣤⣀", " ⢰⣿⡟⢿⣿⠿⢿⡄", " ⣿⡟⢘⡈⡇⣾⢿⣿", " ⠹⣧⣿⣧⣷⣦⣾⠏", "  ⠈⠉⠛⠛⠋"],
+    [" ⣠⣴⣦⣄", "⠰⡟⡊⡳⢾⡆", " ⠙⠻⠟⠋"],
+];
+// 8×8 dots: the small mark in the header.
+export const ICON = ["⢠⡶⢶⡄", "⠘⠶⠾⠃"];

package/dist/cli/intro.js

@@ -0,0 +1,121 @@
+// The intro, after landing/preloader.js: the AC medallion spins, "AgentCollar" types itself
+// and un-types, then the medallion shrinks into the header. About 1.7 s; any key skips it.
+// The frames are plain text made once from the logo (see tools/gen-intro.ts).
+import { styleText } from "node:util";
+import { ICON, SHRINK, SPIN, SPIN_SMALL } from "./intro-frames.js";
+const WORD = "AgentCollar";
+const WELCOME = "Welcome. Let agents work. Keep the keys.";
+const WELCOME_SHORT = "Let agents work. Keep the keys.";
+// The big medallion needs 60×16, the small one 44×12; a smaller window gets no intro at all.
+export function introSize(columns, rows) {
+    if (columns >= 60 && rows >= SPIN[0].length + 4)
+        return "big";
+    if (columns >= 44 && rows >= SPIN_SMALL[0].length + 4)
+        return "small";
+    return "none";
+}
+// The whole animation as data: easy to test (duration, sizes) and to play.
+export function introTimeline(size = "big", width = 100) {
+    const spin = size === "big" ? SPIN : SPIN_SMALL;
+    const height = spin[0].length; // every frame has this many lines, so each one overwrites the last
+    const wordRow = Math.floor(height / 2) - 1;
+    const wordColumn = Math.max(...spin[0].map((line) => [...line].length)) + 3;
+    const frame = (medallion, word = "", delayMs = 0) => ({
+        lines: Array.from({ length: height }, (_, row) => {
+            const left = medallion[row] ?? "";
+            return row === wordRow && word !== "" ? left.padEnd(wordColumn) + word : left;
+        }),
+        delayMs,
+    });
+    const upright = spin[0];
+    const frames = [];
+    for (const turned of spin)
+        frames.push(frame(turned, "", 40)); // one full turn
+    frames.push(frame(upright, "", 40)); // settles upright
+    for (let i = 1; i <= WORD.length; i++)
+        frames.push(frame(upright, WORD.slice(0, i), 45)); // types
+    frames[frames.length - 1].delayMs = 250; // holds the full name
+    for (let i = WORD.length - 1; i >= 0; i--)
+        frames.push(frame(upright, WORD.slice(0, i), 22)); // un-types
+    const shrink = size === "big" ? SHRINK : SHRINK.slice(1); // the small intro starts at 32 dots already
+    for (const smaller of shrink)
+        frames.push(frame(smaller, "", 60)); // flies into the header
+    const welcome = width >= WELCOME.length + 6 ? WELCOME : WELCOME_SHORT;
+    frames.push(frame([`${ICON[0]}  ${styleText("bold", WORD)}`, `${ICON[1]}  ${welcome}`]));
+    return frames;
+}
+// Only for a person looking at a real terminal: never in pipes, logs, CI, or when asked not to.
+export function shouldShowIntro(c) {
+    if (c.noIntro || !c.stdoutTTY)
+        return false;
+    if (c.env.CI !== undefined || c.env.TERM === "dumb")
+        return false;
+    if (c.env.NO_COLOR !== undefined && c.env.NO_COLOR !== "")
+        return false; // no-color.org rule
+    return introSize(c.columns, c.rows) !== "none";
+}
+// ANSI escape codes used below:
+//   ESC[?25l / ESC[?25h  hide / show the cursor
+//   ESC 7 / ESC 8        save / restore the cursor position
+//   ESC[2K               clear the current line
+//   ESC[J                clear from the cursor to the end of the screen
+//   ESC[<n>A             move the cursor n lines up
+const ESC = "\u001b";
+export async function playIntro(out = process.stdout, input = process.stdin) {
+    const size = introSize(out.columns ?? 100, out.rows ?? 40);
+    if (size === "none")
+        return;
+    const frames = introTimeline(size, out.columns ?? 100);
+    const HEIGHT = frames[0].lines.length;
+    let skipped = false;
+    let ctrlC = false;
+    let wake = () => { };
+    const showCursor = () => out.write(`${ESC}[?25h`);
+    process.once("exit", showCursor); // even if something goes wrong, never leave the cursor hidden
+    const onKey = (key) => {
+        skipped = true;
+        ctrlC = key[0] === 3; // Ctrl+C
+        wake();
+    };
+    if (input.isTTY) {
+        input.setRawMode(true);
+        input.resume();
+        input.on("data", onKey);
+    }
+    // make room for the frames, go back up, and remember where the block starts
+    out.write(`${ESC}[?25l${"\n".repeat(HEIGHT)}${ESC}[${HEIGHT}A${ESC}7`);
+    const draw = (lines) => out.write(`${ESC}8${lines.map((line) => `${ESC}[2K${line}`).join("\n")}`);
+    for (const f of frames.slice(0, -1)) {
+        if (skipped)
+            break;
+        draw(f.lines);
+        await new Promise((resolve) => {
+            wake = resolve;
+            setTimeout(resolve, f.delayMs);
+        });
+    }
+    // the header stays; everything below it is cleared
+    const header = frames[frames.length - 1].lines.filter((line) => line !== "");
+    out.write(`${ESC}8${ESC}[J${header.join("\n")}\n\n`);
+    showCursor();
+    process.off("exit", showCursor);
+    if (input.isTTY) {
+        input.off("data", onKey);
+        input.setRawMode(false);
+        input.pause();
+    }
+    if (ctrlC)
+        process.exit(130);
+}
+// Shows the intro only when it makes sense (see shouldShowIntro).
+export async function maybeIntro(noIntro) {
+    const context = {
+        stdoutTTY: process.stdout.isTTY === true,
+        columns: process.stdout.columns ?? 0,
+        rows: process.stdout.rows ?? 0,
+        env: process.env,
+        noIntro,
+    };
+    if (shouldShowIntro(context))
+        await playIntro();
+}

package/dist/cli/logs.js

@@ -0,0 +1,46 @@
+// agentcollar logs [--agent <name>] [--denied] [--today] — the audit log, readable and filtered.
+import { readAuditLog } from "../audit-log.js";
+import { auditLogFile } from "../audit.js";
+import { formatEntry, isSameLocalDay } from "./format.js";
+export function parseLogsArgs(args) {
+    const filter = { agent: null, denied: false, today: false };
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+        if (arg === "--denied")
+            filter.denied = true;
+        else if (arg === "--today")
+            filter.today = true;
+        else if (arg === "--agent") {
+            const name = args[++i];
+            if (name === undefined || name.startsWith("--"))
+                throw new Error("--agent needs a name: --agent <name>");
+            filter.agent = name;
+        }
+        else
+            throw new Error(`Unknown flag: ${arg}. Available: --agent <name>, --denied, --today`);
+    }
+    return filter;
+}
+export function filterEntries(entries, filter, now = new Date()) {
+    return entries.filter((entry) => (filter.agent === null || entry.agent === filter.agent) &&
+        (!filter.denied || !entry.allowed) &&
+        (!filter.today || isSameLocalDay(new Date(entry.time), now)));
+}
+export async function runLogs(args) {
+    let filter;
+    try {
+        filter = parseLogsArgs(args);
+    }
+    catch (error) {
+        console.error(error.message);
+        return 1;
+    }
+    const entries = filterEntries(readAuditLog(auditLogFile), filter);
+    if (entries.length === 0) {
+        console.log("No entries.");
+        return 0;
+    }
+    for (const entry of entries)
+        console.log(formatEntry(entry, { showDate: !filter.today }));
+    return 0;
+}

package/dist/cli/main.js

@@ -0,0 +1,104 @@
+// agcl <command> [arguments] — one entry point for the broker. `agentcollar` is the same program:
+// both names point to one file, so `agcl watch` == `agentcollar watch`.
+// Each command lives in its own file and is loaded only when it is used.
+import { styleText } from "node:util";
+import { fit, termWidth, wrap } from "./format.js";
+// Runs forever (until Ctrl+C): the server and the MCP server keep the process alive themselves.
+const forever = () => new Promise(() => { });
+const COMMANDS = {
+    setup: {
+        usage: "agcl setup",
+        summary: "connect your own Telegram bot (setup wizard)",
+        run: async () => (await import("./setup.js")).runSetup(),
+    },
+    gmail: {
+        usage: "agcl gmail connect|status|disconnect",
+        summary: "connect your real Gmail (read + create drafts; cannot send)",
+        run: async (args) => (await import("./gmail.js")).runGmail(args),
+    },
+    server: {
+        usage: "agcl server",
+        summary: "start the broker on 127.0.0.1",
+        run: async () => {
+            await import("../server.js");
+            return forever();
+        },
+    },
+    watch: {
+        usage: "agcl watch",
+        summary: "live screen: agent requests as they happen, with the 6 checks",
+        run: async (args, flags) => {
+            await (await import("./intro.js")).maybeIntro(flags.noIntro);
+            return (await import("./watch.js")).runWatch(args);
+        },
+    },
+    mandates: {
+        usage: "agcl mandates",
+        summary: "mandates of the running broker: state, time and actions left",
+        run: async (args) => (await import("./mandates.js")).runMandates(args),
+    },
+    logs: {
+        usage: "agcl logs [--agent <name>] [--denied] [--today]",
+        summary: "the audit log: who, what, when, allowed or not",
+        run: async (args) => (await import("./logs.js")).runLogs(args),
+    },
+    revoke: {
+        usage: "agcl revoke <id>",
+        summary: "revoke a mandate instantly (kill switch)",
+        run: async (args) => (await import("./revoke.js")).runRevoke(args),
+    },
+    mcp: {
+        usage: "agcl mcp",
+        summary: "MCP server for Claude Code and other agents (stdio)",
+        run: async () => {
+            await import("../mcp/server.js");
+            return forever();
+        },
+    },
+};
+export function parseCommand(argv) {
+    const flags = { noIntro: argv.includes("--no-intro") };
+    const [name, ...args] = argv.filter((word) => word !== "--no-intro");
+    if (name === undefined)
+        return { kind: "default", flags };
+    if (name === "help" || name === "--help" || name === "-h")
+        return { kind: "help" };
+    if (!Object.hasOwn(COMMANDS, name))
+        return { kind: "unknown", name };
+    return { kind: "run", name, args, flags };
+}
+function helpText() {
+    const screen = termWidth();
+    const width = Math.max(...Object.values(COMMANDS).map((c) => c.usage.length)) + 3;
+    // wide window: "usage   summary" on one line; narrow: the summary goes under the usage
+    const row = (left, right) => screen >= width + 40
+        ? `  ${styleText("cyan", left.padEnd(width))}${fit(right, screen - width - 2)}`
+        : `  ${styleText("cyan", fit(left, screen - 2))}\n${wrap(right, screen - 6).map((line) => `      ${line}`).join("\n")}`;
+    return [
+        fit(`${styleText("bold", "AgentCollar")} — let agents work, keep the keys.`, screen + 20),
+        "",
+        row("agcl", "intro → setup wizard (first time only) → broker"),
+        ...Object.values(COMMANDS).map((c) => row(c.usage, c.summary)),
+        "",
+        row("--no-intro", "skip the intro"),
+        row("-h, --help", "this help"),
+        "",
+        styleText("dim", fit("agcl is the short name of agentcollar: agcl watch == agentcollar watch", screen)),
+        styleText("dim", fit("Your data: ~/.agentcollar/ (only you can open it)", screen)),
+    ].join("\n");
+}
+export async function runCli(argv) {
+    const parsed = parseCommand(argv);
+    switch (parsed.kind) {
+        case "default":
+            return (await import("./start.js")).runStart(parsed.flags);
+        case "help":
+            console.log(helpText());
+            return 0;
+        case "unknown":
+            console.error(`${styleText("red", `Unknown command: ${parsed.name}`)}\n\n${helpText()}`);
+            return 1;
+        case "run":
+            return COMMANDS[parsed.name].run(parsed.args, parsed.flags);
+    }
+}

package/dist/cli/mandates.js

@@ -0,0 +1,101 @@
+// agentcollar mandates — the mandates of the running broker: who, what, state, time and actions left.
+import { styleText } from "node:util";
+import { oneLine } from "../approval.js";
+import { readMandatesSnapshot } from "../snapshot.js";
+import { fit, termWidth } from "./format.js";
+function duration(ms) {
+    const total = Math.ceil(ms / 1000);
+    const h = Math.floor(total / 3600);
+    const m = Math.floor((total % 3600) / 60);
+    const s = String(total % 60).padStart(2, "0");
+    return h > 0 ? `${h}:${String(m).padStart(2, "0")}:${s}` : `${m}:${s}`;
+}
+// The same order as check(): the first thing that ends a mandate decides its name.
+export function mandateRow(m, now = Date.now()) {
+    let state = "active";
+    if (m.status === "pending")
+        state = "waiting";
+    else if (m.status === "denied")
+        state = "denied";
+    else if (now > m.expiresAt)
+        state = "expired";
+    else if (m.revoked)
+        state = "revoked";
+    else if (m.used >= m.limit)
+        state = "limit used up";
+    const live = state === "active";
+    return {
+        id: m.id,
+        agent: oneLine(m.agent, 24), // agent text: control characters removed before printing
+        actions: m.allowedActions.join(", "),
+        state,
+        timeLeft: live ? duration(m.expiresAt - now) : "—",
+        limit: `${m.used}/${m.limit}`,
+        live,
+    };
+}
+// Is the server process still running? Signal 0 checks without touching it.
+function isRunning(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (error) {
+        return error.code === "EPERM"; // exists, but belongs to someone else
+    }
+}
+const COLUMNS = ["ID", "AGENT", "ACTIONS", "STATE", "TIME LEFT", "USED"];
+function colorState(row, text) {
+    if (row.live)
+        return styleText("green", text);
+    if (row.state === "waiting")
+        return styleText("yellow", text);
+    return text;
+}
+// A table when it fits the window, otherwise one small "card" (two lines) per mandate.
+export function formatMandates(mandates, now = Date.now(), width = termWidth()) {
+    const rows = [...mandates].sort((a, b) => b.createdAt - a.createdAt).map((m) => mandateRow(m, now));
+    const cells = (r) => [r.id, r.agent, r.actions, r.state, r.timeLeft, r.limit];
+    const widths = COLUMNS.map((title, i) => Math.max(title.length, ...rows.map((r) => cells(r)[i].length)));
+    const tableWidth = widths.reduce((sum, w) => sum + w, 0) + 2 * (widths.length - 1);
+    const dimIfEnded = (row, text) => (row.live || row.state === "waiting" ? text : styleText("dim", text));
+    if (tableWidth <= width) {
+        // pad first, color after: color codes are invisible but would break the padding
+        const lines = [styleText("dim", COLUMNS.map((title, i) => title.padEnd(widths[i])).join("  "))];
+        for (const row of rows) {
+            const line = cells(row).map((c, i) => c.padEnd(widths[i]));
+            line[3] = colorState(row, line[3]);
+            lines.push(dimIfEnded(row, line.join("  ")));
+        }
+        return lines.join("\n");
+    }
+    return rows
+        .map((row) => {
+        const time = row.timeLeft === "—" ? "" : `  ${row.timeLeft} left`;
+        const head = fit(`${row.id}  ${row.state}${time}  ${row.limit} used`, width);
+        const colored = head.replace(row.state, colorState(row, row.state));
+        return dimIfEnded(row, `${colored}\n  ${fit(`${row.agent} · ${row.actions}`, width - 2)}`);
+    })
+        .join("\n");
+}
+export async function runMandates(args) {
+    if (args.length > 0) {
+        console.error(`agcl mandates takes no arguments: ${args.join(" ")}`);
+        return 1;
+    }
+    const snapshot = readMandatesSnapshot();
+    if (snapshot === null) {
+        console.log("The broker has not been started yet. Run: agcl server");
+        return 0;
+    }
+    if (!isRunning(snapshot.pid)) {
+        console.log("The broker is not running. Mandates live in its memory, so they are gone once it stops.");
+        return 0;
+    }
+    if (snapshot.mandates.length === 0) {
+        console.log("No mandates yet.");
+        return 0;
+    }
+    console.log(formatMandates(snapshot.mandates));
+    return 0;
+}

package/dist/cli/revoke.js

@@ -0,0 +1,8 @@
+// agentcollar revoke <id> — the local kill switch from the terminal.
+import "../env.js";
+import { revokeMandate } from "../revoke.js";
+export async function runRevoke(args) {
+    const result = await revokeMandate(args[0] ?? "", Number(process.env.BROKER_PORT ?? 8787));
+    console.log(result.message);
+    return result.ok ? 0 : 1;
+}

package/dist/cli/setup.js

@@ -0,0 +1,124 @@
+// agcl setup (= agentcollar setup, npm run setup) — connects the broker to YOUR Telegram bot, without editing files by hand.
+// 1) asks for the bot token and checks it with Telegram,
+// 2) you press Start in the bot: we take your user id from that message,
+// 3) writes ~/.agentcollar/.env readable only by you (600).
+import { existsSync, readFileSync } from "node:fs";
+import { createInterface } from "node:readline/promises";
+import { ensureHome, envFile, homeDir, legacyFiles, migrateLegacy } from "../paths.js";
+import { buildEnv, getBotUsername, newStartCode, pollForStart, sendText, skipOldUpdates, writeEnvFile, } from "../setup.js";
+const WAIT_MS = 5 * 60 * 1000;
+async function ask(question) {
+    const rl = createInterface({ input: process.stdin, output: process.stdout });
+    try {
+        // If the input ends before an answer (Ctrl+D, closed pipe), fail loudly instead of exiting silently.
+        const answer = await new Promise((resolve, reject) => {
+            rl.question(question).then(resolve, reject);
+            rl.once("close", () => reject(new Error("input ended, nothing was written")));
+        });
+        return answer.trim();
+    }
+    finally {
+        rl.close();
+    }
+}
+const yes = (answer) => answer.toLowerCase() === "y";
+// Reads a line without showing it (for the token). Node has no ready-made "password input",
+// so we switch the terminal to raw mode and read key by key, printing nothing.
+function askHidden(question) {
+    const stdin = process.stdin;
+    if (!stdin.isTTY)
+        return ask(question); // input is piped, not typed: nothing to hide
+    return new Promise((resolve) => {
+        process.stdout.write(question);
+        stdin.setRawMode(true);
+        stdin.setEncoding("utf8");
+        stdin.resume();
+        let value = "";
+        const onData = (chunk) => {
+            for (const char of chunk) {
+                if (char === "\r" || char === "\n") {
+                    stdin.setRawMode(false);
+                    stdin.pause();
+                    stdin.off("data", onData);
+                    process.stdout.write("\n");
+                    return resolve(value.trim());
+                }
+                if (char === "\u0003")
+                    process.exit(130); // Ctrl+C
+                if (char === "\u007f")
+                    value = value.slice(0, -1); // Backspace
+                else
+                    value += char;
+            }
+        };
+        stdin.on("data", onData);
+    });
+}
+export async function runSetup() {
+    try {
+        return await setup();
+    }
+    catch (error) {
+        console.error(`\n✗ ${error.message}`);
+        return 1;
+    }
+}
+async function setup() {
+    console.log("AgentCollar setup\n");
+    // Older versions kept the data inside the code folder (broker/.env, broker/data/audit.log).
+    const oldFiles = [legacyFiles.env, legacyFiles.audit].filter((file) => existsSync(file));
+    if (oldFiles.length > 0) {
+        console.log(`Found data from an older version:\n${oldFiles.map((f) => `  ${f}`).join("\n")}`);
+        if (yes(await ask(`Move it to ${homeDir}/ (only you can open that folder)? [y/N] `))) {
+            const moved = migrateLegacy();
+            console.log(moved.length > 0 ? `✓ Moved: ${moved.join(", ")}\n` : "Files already exist there; the old ones stay where they are.\n");
+        }
+    }
+    if (existsSync(envFile) && !yes(await ask(`${envFile} already exists. Replace the Telegram settings? [y/N] `))) {
+        console.log("Nothing changed.");
+        return 0;
+    }
+    // 1. Token
+    let token = "";
+    let username = "";
+    while (username === "") {
+        token = await askHidden("Bot token (from @BotFather, hidden while you type): ");
+        try {
+            username = await getBotUsername(token);
+        }
+        catch (error) {
+            console.log(`✗ ${error.message}\n`);
+        }
+    }
+    console.log(`✓ Bot found: @${username}\n`);
+    // 2. Start with a one-time code
+    const code = newStartCode();
+    let offset = await skipOldUpdates(token);
+    console.log(`Open this link and press Start:  https://t.me/${username}?start=${code}`);
+    console.log("Waiting (up to 5 minutes)...");
+    let user;
+    const deadline = Date.now() + WAIT_MS;
+    while (user === undefined && Date.now() < deadline) {
+        const round = await pollForStart(token, code, offset);
+        user = round.user;
+        offset = round.offset;
+    }
+    await skipOldUpdates(token); // tell Telegram we handled these messages
+    if (user === undefined) {
+        console.log("Timed out. Run agcl setup again.");
+        return 1;
+    }
+    const who = [user.firstName, user.username ? `@${user.username}` : "", `id ${user.id}`].filter(Boolean).join(", ");
+    if (!yes(await ask(`✓ Is this you? ${who} [y/N] `))) {
+        console.log("Nothing was written. Run agcl setup again.");
+        return 1;
+    }
+    // 3. ~/.agentcollar/.env, readable only by you
+    ensureHome();
+    const existing = existsSync(envFile) ? readFileSync(envFile, "utf8") : "";
+    writeEnvFile(envFile, buildEnv(existing, { TELEGRAM_BOT_TOKEN: token, TELEGRAM_USER_ID: String(user.id) }));
+    await sendText(token, user.id, "✅ AgentCollar is set up. Mandate requests will arrive here.").catch(() => { });
+    console.log(`✓ Saved to ${envFile} (mode 600: only your macOS user can read it)`);
+    console.log("Next: agcl server (or just agcl)");
+    return 0;
+}

package/dist/cli/start.js

@@ -0,0 +1,29 @@
+// `agcl` with no command: the intro, then the setup wizard if Telegram is not set up yet,
+// then the broker itself. One word from install to a running broker.
+import "../env.js";
+import { existsSync } from "node:fs";
+import { createInterface } from "node:readline/promises";
+import { envFile } from "../paths.js";
+async function ask(question) {
+    const rl = createInterface({ input: process.stdin, output: process.stdout });
+    const answer = await rl.question(question);
+    rl.close();
+    return answer.trim().toLowerCase();
+}
+export async function runStart(flags) {
+    await (await import("./intro.js")).maybeIntro(flags.noIntro);
+    // Ask only a person at a terminal; a script or pipe goes straight to the server.
+    const configured = (process.env.TELEGRAM_BOT_TOKEN ?? "") !== "";
+    if (!configured && process.stdin.isTTY) {
+        const answer = await ask("Telegram is not set up yet. Set it up now? [Y/n] (n = approve requests in this terminal) ");
+        if (answer === "" || answer === "y") {
+            const code = await (await import("./setup.js")).runSetup();
+            if (code !== 0)
+                return code;
+            if (existsSync(envFile))
+                process.loadEnvFile(envFile); // the server reads the new settings
+        }
+    }
+    await import("../server.js");
+    return new Promise(() => { }); // the server runs until Ctrl+C
+}

package/dist/cli/tail.js

@@ -0,0 +1,46 @@
+// Like `tail -f`: each readNew() returns only the entries appended since the previous call.
+import { closeSync, existsSync, openSync, readSync, statSync } from "node:fs";
+import { parseAuditLine } from "../audit-log.js";
+const NEWLINE = 0x0a; // the byte of "\n"
+export function createTail(file) {
+    let offset = 0; // how many bytes we have already read
+    let rest = Buffer.alloc(0); // bytes after the last "\n": a line the server is still writing
+    return {
+        readNew() {
+            if (!existsSync(file))
+                return [];
+            const size = statSync(file).size;
+            if (size < offset) {
+                // the file got shorter: it was cut or replaced, so start over
+                offset = 0;
+                rest = Buffer.alloc(0);
+            }
+            if (size === offset)
+                return [];
+            const chunk = Buffer.alloc(size - offset);
+            const fd = openSync(file, "r");
+            try {
+                readSync(fd, chunk, 0, chunk.length, offset);
+            }
+            finally {
+                closeSync(fd);
+            }
+            offset = size;
+            // Work with BYTES up to the last "\n". Turning a half line into text could cut a
+            // Cyrillic letter (2 bytes) in the middle and break it; the rest waits for the next call.
+            const bytes = Buffer.concat([rest, chunk]);
+            const end = bytes.lastIndexOf(NEWLINE);
+            if (end === -1) {
+                rest = bytes;
+                return [];
+            }
+            rest = bytes.subarray(end + 1);
+            return bytes
+                .subarray(0, end)
+                .toString("utf8")
+                .split("\n")
+                .map(parseAuditLine)
+                .filter((entry) => entry !== null);
+        },
+    };
+}