abtars 0.1.0-alpha.2 → 0.1.0-alpha.21

package/bundle/chunk-TXRWQIQQ.js

@@ -0,0 +1,3707 @@
+#!/usr/bin/env node
+ import { createRequire as __bundleCreateRequire } from 'node:module'; import { fileURLToPath as __bundleFileURLToPath } from 'node:url'; import { dirname as __bundleDirname } from 'node:path'; const require = __bundleCreateRequire(import.meta.url); const __chunk_filename = __bundleFileURLToPath(import.meta.url); const __chunk_dirname = __bundleDirname(__chunk_filename);
+import {
+  require_ws
+} from "./chunk-NIRYBWUW.js";
+import {
+  transcribeAudio
+} from "./chunk-3MO2MDXJ.js";
+import {
+  ModelNotFoundError
+} from "./chunk-WX7GHGFX.js";
+import {
+  loadMinimalSoul,
+  loadSoulBundle
+} from "./chunk-AUQD2PKM.js";
+import {
+  loadUsers
+} from "./chunk-J5YIMCLT.js";
+import {
+  abmind
+} from "./chunk-JAJ3DUQ2.js";
+import {
+  fire,
+  hasHooks
+} from "./chunk-G6IXMYIO.js";
+import {
+  readAndClearRestartReason,
+  readBridgeLockField,
+  updateBridgeLockField,
+  writeForceSleep,
+  writeSleepStatus
+} from "./chunk-UDZIZB5F.js";
+import {
+  readEntries
+} from "./chunk-XLLSPBBT.js";
+import {
+  localTime
+} from "./chunk-MZWMYN4O.js";
+import {
+  init_log_and_swallow,
+  logAndSwallow
+} from "./chunk-EX2SRTUE.js";
+import {
+  getEnv,
+  init_env_schema
+} from "./chunk-AQVOAQQI.js";
+import {
+  init_logger,
+  logDebug,
+  logError,
+  logInfo,
+  logTrace,
+  logWarn
+} from "./chunk-2BY6I4P5.js";
+import {
+  abtarsHome,
+  init_paths
+} from "./chunk-MJ6PHMOK.js";
+import {
+  __commonJS,
+  __require,
+  __toESM
+} from "./chunk-7K2YZTLD.js";
+
+// node_modules/@andresaya/edge-tts/dist/config/constants.js
+var require_constants = __commonJS({
+  "node_modules/@andresaya/edge-tts/dist/config/constants.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.Constants = void 0;
+    exports.Constants = {
+      TRUSTED_CLIENT_TOKEN: "6A5AA1D4EAFF4E9FB37E23D68491D6F4",
+      BASE_URL: "https://speech.platform.bing.com/consumer/speech/synthesize/readaloud",
+      WSS_URL: "wss://speech.platform.bing.com/consumer/speech/synthesize/readaloud/edge/v1",
+      VOICES_URL: "https://speech.platform.bing.com/consumer/speech/synthesize/readaloud/voices/list",
+      CHROMIUM_FULL_VERSION: "143.0.3650.75",
+      CHROMIUM_MAJOR_VERSION: "143",
+      VERSION_MS_GEC: "1-143.0.3650",
+      token32() {
+        const bytes = new Uint8Array(16);
+        crypto.getRandomValues(bytes);
+        return Array.from(bytes).map((b) => b.toString(16).padStart(2, "0")).join("").toUpperCase();
+      },
+      getBaseHeaders() {
+        return {
+          "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/143.0.0.0 Safari/537.36 Edg/143.0.0.0",
+          "Accept-Encoding": "gzip, deflate, br, zstd",
+          "Accept-Language": "en-US,en;q=0.9",
+          "Cookie": "MUID=" + this.token32()
+        };
+      },
+      WSS_HEADERS: {
+        "Pragma": "no-cache",
+        "Cache-Control": "no-cache",
+        "Origin": "chrome-extension://jdiccldimpdaibmpdkjnbmckianbfold",
+        "Sec-WebSocket-Protocol": "synthesize",
+        "Sec-WebSocket-Version": "13",
+        "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/143.0.3650.75 Safari/537.36 Edg/143.0.3650.75"
+      },
+      VOICE_HEADERS: {
+        "Sec-CH-UA": '" Not;A Brand";v="99", "Microsoft Edge";v="143", "Chromium";v="143"',
+        "Sec-CH-UA-Mobile": "?0",
+        "Accept": "*/*",
+        "Sec-Fetch-Site": "none",
+        "Sec-Fetch-Mode": "cors",
+        "Sec-Fetch-Dest": "empty"
+      },
+      // https://learn.microsoft.com/en-us/azure/ai-services/speech-service/rest-text-to-speech?tabs=nonstreaming
+      OUTPUT_FORMAT: {
+        "AUDIO_24KHZ_48KBITRATE_MONO_MP3": "audio-24khz-48kbitrate-mono-mp3",
+        "AUDIO_24KHZ_96KBITRATE_MONO_MP3": "audio-24khz-96kbitrate-mono-mp3",
+        "WEBM_24KHZ_16BIT_MONO_OPUS": "webm-24khz-16bit-mono-opus"
+      }
+    };
+  }
+});
+
+// node_modules/@andresaya/edge-tts/dist/services/EdgeTTS.js
+var require_EdgeTTS = __commonJS({
+  "node_modules/@andresaya/edge-tts/dist/services/EdgeTTS.js"(exports) {
+    "use strict";
+    var __importDefault = exports && exports.__importDefault || function(mod) {
+      return mod && mod.__esModule ? mod : { "default": mod };
+    };
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.EdgeTTS = void 0;
+    var ws_1 = __importDefault(require_ws());
+    var constants_1 = require_constants();
+    var promises_1 = __require("fs/promises");
+    var buffer_1 = __require("buffer");
+    var https_1 = __importDefault(__require("https"));
+    function ensureBuffer(data) {
+      if (buffer_1.Buffer.isBuffer(data)) {
+        return data;
+      }
+      if (data instanceof ArrayBuffer) {
+        return buffer_1.Buffer.from(data);
+      }
+      if (Array.isArray(data)) {
+        return buffer_1.Buffer.concat(data);
+      }
+      if (typeof data === "string") {
+        return buffer_1.Buffer.from(data, "utf-8");
+      }
+      throw new Error(`Unsupported RawData type: ${typeof data}`);
+    }
+    var EdgeTTS2 = class {
+      audio_stream = [];
+      audio_format = "mp3";
+      output_format = "audio-24khz-48kbitrate-mono-mp3";
+      word_boundaries = [];
+      ws;
+      async normalizeVoices(data) {
+        const out = [];
+        for (const v of data || []) {
+          const short = v?.ShortName || "";
+          const locale = v?.Locale || "";
+          let base = short.replace(/^[a-z]{2}-[A-Z]{2}-/, "");
+          base = base.replace(/NeuralHD$/, "").replace(/Neural$/, "").trim();
+          const mix = `${v?.Name || ""} ${short}`;
+          const voiceType = v?.VoiceType || (/NeuralHD/i.test(mix) ? "NeuralHD" : "Neural");
+          const localeName = v?.LocaleName || (locale || null);
+          let display = v?.DisplayName || v?.FriendlyName || base || short;
+          display = display.replace(/^Microsoft\s+/i, "");
+          display = display.split(" - ")[0].trim();
+          display = display.replace(/\s*Online\s*\(Natural\)\s*/i, " ");
+          display = display.replace(/\s*Online\s*/i, " ");
+          display = display.replace(/\s+/g, " ").trim();
+          const tag = v?.VoiceTag && typeof v.VoiceTag === "object" ? v.VoiceTag : {};
+          const tailored = Array.isArray(tag.TailoredScenarios) ? tag.TailoredScenarios : Array.isArray(tag.ContentCategories) ? tag.ContentCategories : [];
+          const personalities = Array.isArray(tag.VoicePersonalities) ? tag.VoicePersonalities : [];
+          out.push({
+            Name: short || (v?.Name || ""),
+            DisplayName: display,
+            LocalName: display,
+            ShortName: short || (v?.Name || ""),
+            Gender: v?.Gender ?? null,
+            Locale: locale || null,
+            LocaleName: localeName,
+            SecondaryLocaleList: Array.isArray(v?.SecondaryLocaleList) ? v.SecondaryLocaleList : [],
+            VoiceType: voiceType,
+            VoiceTag: {
+              TailoredScenarios: tailored,
+              VoicePersonalities: personalities
+            },
+            FriendlyName: `${display} (${voiceType}) - ${localeName}`
+          });
+        }
+        return out;
+      }
+      async getVoices() {
+        const secMsGEC = await this.generateSecMsGec(constants_1.Constants.TRUSTED_CLIENT_TOKEN);
+        const httpsAgent = new https_1.default.Agent({ rejectUnauthorized: false });
+        const url = `${constants_1.Constants.VOICES_URL}?TrustedClientToken=${constants_1.Constants.TRUSTED_CLIENT_TOKEN}&Sec-MS-GEC=${secMsGEC}&Sec-MS-GEC-Version=${constants_1.Constants.VERSION_MS_GEC}`;
+        const headers = {
+          ...constants_1.Constants.getBaseHeaders(),
+          "Accept-Encoding": "identity"
+          // evita gzip/br/zstd
+        };
+        const voicesRaw = await new Promise((resolve, reject) => {
+          const req = https_1.default.request(url, { method: "GET", headers, agent: httpsAgent }, (res) => {
+            const chunks = [];
+            res.on("data", (chunk) => chunks.push(buffer_1.Buffer.isBuffer(chunk) ? chunk : buffer_1.Buffer.from(chunk)));
+            res.on("error", reject);
+            res.on("end", () => {
+              const body = buffer_1.Buffer.concat(chunks).toString("utf8");
+              try {
+                const parsed = JSON.parse(body);
+                const voices = Array.isArray(parsed) ? parsed : parsed.voices || parsed.Voices || [];
+                resolve(Array.isArray(voices) ? voices : []);
+              } catch (e) {
+                reject(new Error("JSON inv\xE1lido: " + (e?.message || String(e))));
+              }
+            });
+          });
+          req.on("error", reject);
+          req.end();
+        });
+        return this.normalizeVoices(voicesRaw);
+      }
+      async getVoicesByLanguage(locale) {
+        const voices = await this.getVoices();
+        return voices.filter((voice) => voice.Locale.startsWith(locale));
+      }
+      async getVoicesByGender(gender) {
+        const voices = await this.getVoices();
+        return voices.filter((voice) => voice.Gender === gender);
+      }
+      generateUUID() {
+        return "xxxxxxxx-xxxx-xxxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, function(c) {
+          const r = Math.random() * 16 | 0;
+          const v = c === "x" ? r : r & 3 | 8;
+          return v.toString(16);
+        });
+      }
+      validatePitch(pitch) {
+        if (typeof pitch === "number") {
+          return pitch >= 0 ? `+${pitch}Hz` : `${pitch}Hz`;
+        }
+        if (!/^[+-]?\d{1,3}(?:\.\d+)?Hz$/.test(pitch)) {
+          throw new Error("Invalid pitch format. Expected format: '-100Hz to +100Hz' or a number.");
+        }
+        return pitch;
+      }
+      validateRate(rate) {
+        let rateValue;
+        if (typeof rate === "string") {
+          rateValue = parseFloat(rate.replace("%", ""));
+          if (isNaN(rateValue))
+            throw new Error("Invalid rate format.");
+        } else {
+          rateValue = rate;
+        }
+        if (rateValue >= 0) {
+          return `+${rateValue}%`;
+        }
+        return `${rateValue}%`;
+      }
+      validateVolume(volume) {
+        let volumeValue;
+        if (typeof volume === "string") {
+          volumeValue = parseInt(volume.replace("%", ""), 10);
+          if (isNaN(volumeValue))
+            throw new Error("Invalid volume format.");
+        } else {
+          volumeValue = volume;
+        }
+        if (volumeValue < -100 || volumeValue > 100) {
+          throw new Error("Volume cannot be negative. Expected a value from -100% to 100% (or more).");
+        }
+        return `${volumeValue}%`;
+      }
+      async synthesize(text, voice = "en-US-AnaNeural", options = {}) {
+        const secMsGEC = await this.generateSecMsGec(constants_1.Constants.TRUSTED_CLIENT_TOKEN);
+        return new Promise((resolve, reject) => {
+          this.audio_stream = [];
+          const reqId = this.generateUUID();
+          const url = `${constants_1.Constants.WSS_URL}?TrustedClientToken=${constants_1.Constants.TRUSTED_CLIENT_TOKEN}&Sec-MS-GEC=${secMsGEC}&Sec-MS-GEC-Version=${constants_1.Constants.VERSION_MS_GEC}&ConnectionId=${reqId}`;
+          this.ws = new ws_1.default(url, {
+            headers: constants_1.Constants.getBaseHeaders(),
+            rejectUnauthorized: false
+          });
+          const SSML_text = this.getSSML(text, voice, options);
+          const outputFormat = options.outputFormat || "audio-24khz-48kbitrate-mono-mp3";
+          this.output_format = outputFormat;
+          let timedOut = false;
+          let inactivityTimeout;
+          const resetInactivityTimeout = () => {
+            clearTimeout(inactivityTimeout);
+            inactivityTimeout = setTimeout(() => {
+              timedOut = true;
+              if (this.ws && this.ws.readyState === ws_1.default.OPEN) {
+                this.ws.close();
+              }
+              reject(new Error("WebSocket inactivity timeout - no response from server"));
+            }, 3e4);
+          };
+          this.ws.on("open", () => {
+            resetInactivityTimeout();
+            const message = this.buildTTSConfigMessage(outputFormat);
+            this.ws.send(message);
+            const timestamp = this.nowRFC1123();
+            const speechMessage = `X-RequestId:${reqId}\r
+Content-Type:application/ssml+xml\r
+X-Timestamp:${timestamp}\r
+Path:ssml\r
+\r
+${SSML_text}`;
+            this.ws.send(speechMessage);
+          });
+          this.ws.on("message", (data) => {
+            resetInactivityTimeout();
+            this.processAudioData(data);
+          });
+          this.ws.on("error", (err) => {
+            clearTimeout(inactivityTimeout);
+            if (this.ws && this.ws.readyState === ws_1.default.OPEN) {
+              this.ws.close();
+            }
+            reject(err);
+          });
+          this.ws.on("close", () => {
+            clearTimeout(inactivityTimeout);
+            if (!timedOut) {
+              resolve();
+            }
+          });
+        });
+      }
+      escapeXML(text) {
+        return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
+      }
+      getSSML(content, voice, options = {}) {
+        const pitch = this.validatePitch(options.pitch ?? 0);
+        const rate = this.validateRate(options.rate ?? 0);
+        const volume = this.validateVolume(options.volume ?? 0);
+        const escapedText = this.escapeXML(content);
+        return `<speak version="1.0" xmlns="http://www.w3.org/2001/10/synthesis" xmlns:mstts="https://www.w3.org/2001/mstts" xml:lang="en-US">
+                    <voice name="${voice}">
+                        <prosody pitch="${pitch}" rate="${rate}" volume="${volume}">
+                            ${escapedText}
+                        </prosody>
+                    </voice>
+                </speak>
+        `;
+      }
+      nowRFC1123(timeZone = "UTC") {
+        const now = /* @__PURE__ */ new Date();
+        const options = {
+          weekday: "short",
+          year: "numeric",
+          month: "short",
+          day: "2-digit",
+          hour: "2-digit",
+          minute: "2-digit",
+          second: "2-digit",
+          timeZone,
+          timeZoneName: "short"
+        };
+        return now.toLocaleString("en-US", options);
+      }
+      parseRFC1123(rfcStr) {
+        return new Date(rfcStr);
+      }
+      buildTTSConfigMessage(outputFormat = "audio-24khz-48kbitrate-mono-mp3") {
+        const timestamp = this.nowRFC1123();
+        return `X-Timestamp:${timestamp}\r
+Content-Type:application/json; charset=utf-8\r
+Path:speech.config\r
+\r
+{"context":{"synthesis":{"audio":{"metadataoptions":{"sentenceBoundaryEnabled":false,"wordBoundaryEnabled":true},"outputFormat":"${outputFormat}"}}}}`;
+      }
+      async *synthesizeStream(text, voice = "en-US-AnaNeural", options = {}) {
+        this.audio_stream = [];
+        const reqId = this.generateUUID();
+        const secMsGEC = await this.generateSecMsGec(constants_1.Constants.TRUSTED_CLIENT_TOKEN);
+        const url = `${constants_1.Constants.WSS_URL}?TrustedClientToken=${constants_1.Constants.TRUSTED_CLIENT_TOKEN}&Sec-MS-GEC=${secMsGEC}&Sec-MS-GEC-Version=${constants_1.Constants.VERSION_MS_GEC}&ConnectionId=${reqId}`;
+        this.ws = new ws_1.default(url, {
+          headers: constants_1.Constants.getBaseHeaders(),
+          rejectUnauthorized: false
+        });
+        const SSML_text = this.getSSML(text, voice, options);
+        const outputFormat = options.outputFormat || "audio-24khz-48kbitrate-mono-mp3";
+        this.output_format = outputFormat;
+        const queue = [];
+        let done = false;
+        let error = null;
+        let notify = null;
+        const push = (chunk) => {
+          queue.push(chunk);
+          if (notify) {
+            notify();
+            notify = null;
+          }
+        };
+        let timedOut = false;
+        let inactivityTimeout;
+        const resetInactivityTimeout = () => {
+          clearTimeout(inactivityTimeout);
+          inactivityTimeout = setTimeout(() => {
+            timedOut = true;
+            error = new Error("WebSocket inactivity timeout - no response from server");
+            done = true;
+            if (this.ws && this.ws.readyState === ws_1.default.OPEN) {
+              this.ws.close();
+            }
+            if (notify) {
+              notify();
+              notify = null;
+            }
+          }, 3e4);
+        };
+        this.ws.on("open", () => {
+          resetInactivityTimeout();
+          const message = this.buildTTSConfigMessage(outputFormat);
+          this.ws.send(message);
+          const timestamp = this.nowRFC1123();
+          const speechMessage = `X-RequestId:${reqId}\r
+Content-Type:application/ssml+xml\r
+X-Timestamp:${timestamp}\r
+Path:ssml\r
+\r
+${SSML_text}`;
+          this.ws.send(speechMessage);
+        });
+        this.ws.on("message", (data) => {
+          resetInactivityTimeout();
+          const buffer = ensureBuffer(data);
+          const needle = buffer_1.Buffer.from("Path:audio\r\n");
+          const audioStartIndex = buffer.indexOf(new Uint8Array(needle));
+          if (audioStartIndex !== -1) {
+            const audioChunk = buffer.subarray(audioStartIndex + needle.length);
+            const chunk = new Uint8Array(audioChunk);
+            this.audio_stream.push(chunk);
+            push(chunk);
+          }
+          if (buffer.toString().includes("Path:audio.metadata")) {
+            const metadataStart = buffer.indexOf("\r\n\r\n") + 4;
+            const metadataJson = buffer.toString().substring(metadataStart);
+            const meta = this.parseMetadata(metadataJson);
+            if (meta !== null) {
+              this.word_boundaries.push(meta);
+            }
+            return;
+          }
+          if (buffer.toString().includes("Path:turn.end")) {
+            this.ws?.close();
+          }
+        });
+        this.ws.on("error", (err) => {
+          clearTimeout(inactivityTimeout);
+          error = err;
+          done = true;
+          if (notify) {
+            notify();
+            notify = null;
+          }
+        });
+        this.ws.on("close", () => {
+          clearTimeout(inactivityTimeout);
+          done = true;
+          if (notify) {
+            notify();
+            notify = null;
+          }
+        });
+        while (!done || queue.length > 0) {
+          if (queue.length === 0) {
+            await new Promise((resolve) => notify = resolve);
+            continue;
+          }
+          const chunk = queue.shift();
+          if (chunk) {
+            yield chunk;
+          }
+        }
+        if (error) {
+          throw error;
+        }
+      }
+      processAudioData(data) {
+        const buffer = ensureBuffer(data);
+        const needle = buffer_1.Buffer.from("Path:audio\r\n");
+        const audioStartIndex = buffer.indexOf(new Uint8Array(needle));
+        if (audioStartIndex !== -1) {
+          const audioChunk = buffer.subarray(audioStartIndex + needle.length);
+          this.audio_stream.push(new Uint8Array(audioChunk));
+        }
+        if (buffer.toString().includes("Path:audio.metadata")) {
+          const metadataStart = buffer.indexOf("\r\n\r\n") + 4;
+          const metadataJson = buffer.toString().substring(metadataStart);
+          const meta = this.parseMetadata(metadataJson);
+          if (meta !== null) {
+            this.word_boundaries.push(meta);
+          }
+          return;
+        }
+        if (buffer.toString().includes("Path:turn.end")) {
+          this.ws?.close();
+        }
+      }
+      parseMetadata(data, offsetCompensation = 0) {
+        let metadata;
+        try {
+          metadata = JSON.parse(data);
+        } catch {
+          return null;
+        }
+        if (!metadata.Metadata) {
+          return null;
+        }
+        for (const metaObj of metadata.Metadata) {
+          if (metaObj.Type === "WordBoundary") {
+            const currentOffset = metaObj.Data.Offset + offsetCompensation;
+            const currentDuration = metaObj.Data.Duration;
+            return {
+              type: "WordBoundary",
+              offset: currentOffset,
+              duration: currentDuration,
+              text: metaObj.Data.text?.Text
+            };
+          }
+        }
+        return null;
+      }
+      generateSecMsGec = async (trustedClientToken) => {
+        const now = this.nowRFC1123();
+        const fixedDate = this.parseRFC1123(now);
+        const ticks = Math.floor(fixedDate.getTime() / 1e3) + 11644473600;
+        const rounded = ticks - ticks % 300;
+        const windowsTicks = rounded * 1e7;
+        const encoder = new TextEncoder();
+        const data = encoder.encode(`${windowsTicks}${trustedClientToken}`);
+        const hashBuffer = await crypto.subtle.digest("SHA-256", data);
+        return Array.from(new Uint8Array(hashBuffer)).map((b) => b.toString(16).padStart(2, "0")).join("").toUpperCase();
+      };
+      getDuration() {
+        if (this.audio_stream.length === 0) {
+          throw new Error("No audio data available");
+        }
+        const bufferSize = this.toBuffer().length;
+        const estimatedDuration = bufferSize / (24e3 * 3);
+        return estimatedDuration;
+      }
+      getFileExtension(format) {
+        if (format.includes("mp3"))
+          return "mp3";
+        if (format.includes("opus") && format.includes("webm"))
+          return "webm";
+        if (format.includes("opus") && format.includes("ogg"))
+          return "ogg";
+        if (format.includes("wav") || format.includes("riff"))
+          return "wav";
+        if (format.includes("pcm") && format.includes("raw"))
+          return "pcm";
+        if (format.includes("alaw"))
+          return "alaw";
+        if (format.includes("mulaw"))
+          return "mulaw";
+        if (format.includes("truesilk"))
+          return "silk";
+        if (format.includes("g722"))
+          return "g722";
+        if (format.includes("amr"))
+          return "amr";
+        return "audio";
+      }
+      getAudioInfo() {
+        const buffer = this.toBuffer();
+        return {
+          size: buffer.length,
+          format: this.getFileExtension(this.output_format),
+          estimatedDuration: this.getDuration()
+        };
+      }
+      async toFile(outputPath, format) {
+        if (!format) {
+          format = this.getFileExtension(this.output_format);
+        }
+        const audioBuffer = this.toBuffer();
+        const finalPath = `${outputPath}.${format}`;
+        await (0, promises_1.writeFile)(finalPath, new Uint8Array(audioBuffer));
+        return finalPath;
+      }
+      toRaw() {
+        return this.toBase64();
+      }
+      toBase64() {
+        return this.toBuffer().toString("base64");
+      }
+      toBuffer() {
+        if (this.audio_stream.length === 0) {
+          throw new Error("No audio data available. Did you run synthesize() first?");
+        }
+        return buffer_1.Buffer.concat(this.audio_stream);
+      }
+      async saveMetadata(outputPath) {
+        if (this.word_boundaries.length === 0) {
+          throw new Error("No metadata available to save.");
+        }
+        const json = JSON.stringify(this.word_boundaries, null, 4);
+        await (0, promises_1.writeFile)(outputPath, json);
+      }
+      getWordBoundaries() {
+        return this.word_boundaries;
+      }
+    };
+    exports.EdgeTTS = EdgeTTS2;
+  }
+});
+
+// node_modules/@andresaya/edge-tts/dist/index.js
+var require_dist = __commonJS({
+  "node_modules/@andresaya/edge-tts/dist/index.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.Constants = exports.EdgeTTS = void 0;
+    var EdgeTTS_1 = require_EdgeTTS();
+    Object.defineProperty(exports, "EdgeTTS", { enumerable: true, get: function() {
+      return EdgeTTS_1.EdgeTTS;
+    } });
+    var constants_1 = require_constants();
+    Object.defineProperty(exports, "Constants", { enumerable: true, get: function() {
+      return constants_1.Constants;
+    } });
+  }
+});
+
+// src/components/commands/registry.ts
+init_logger();
+
+// src/components/message-pipeline.ts
+init_logger();
+init_log_and_swallow();
+
+// src/components/clean-response.ts
+var REACT_RE = /\[REACT:(.+?)\]/;
+var NO_REPLY_RE = /\s*\[NO[-_]REPLY\]\s*/gi;
+var LANG_TAG_RE = /^\[lang:\w{2}\]\s*/i;
+var TOPICS_RE = /\[TOPICS:\s*(.+?)\]/i;
+var CONTEXT_BLOCK_RE = /\[CONTEXT[^\]]*\][\s\S]*?\[\/CONTEXT\]/gi;
+var MEMORY_BLOCK_RE = /\[MEMORY CONTEXT[^\]]*\][\s\S]*?\[\/MEMORY CONTEXT\]/gi;
+var COMPACT_BLOCK_RE = /\[COMPACTED CONVERSATION\][\s\S]*?\[\/COMPACTED CONVERSATION\]/gi;
+var SESSION_REASON_RE = /\[SESSION START REASON\][^\n]*/gi;
+var CURRENT_USER_RE = /\[CURRENT USER\][^\[]*/gi;
+var FLASHBACK_RE = /\[Flashback\][^\n]*/gi;
+var CURRENT_TIME_RE = /\[Current time:[^\]]*\]/gi;
+function cleanResponse(raw) {
+  const noReply = NO_REPLY_RE.test(raw);
+  NO_REPLY_RE.lastIndex = 0;
+  let text = raw.replace(NO_REPLY_RE, "").replace(LANG_TAG_RE, "").trim();
+  let reactionEmoji;
+  let topics;
+  const reactMatch = text.match(REACT_RE);
+  if (reactMatch) {
+    reactionEmoji = reactMatch[1];
+    text = text.replace(reactMatch[0], "").trim();
+  }
+  const topicsMatch = text.match(TOPICS_RE);
+  if (topicsMatch) {
+    topics = topicsMatch[1].split(",").map((t) => t.trim().toLowerCase()).filter((t) => t.length >= 2);
+    text = text.replace(topicsMatch[0], "").trim();
+  }
+  text = text.replace(CONTEXT_BLOCK_RE, "").replace(MEMORY_BLOCK_RE, "").replace(COMPACT_BLOCK_RE, "").replace(SESSION_REASON_RE, "").replace(CURRENT_USER_RE, "").replace(FLASHBACK_RE, "").replace(CURRENT_TIME_RE, "").replace(/\n{3,}/g, "\n\n").trim();
+  return { text, reactionEmoji, noReply, topics };
+}
+
+// src/components/reactions.ts
+init_log_and_swallow();
+init_logger();
+var TAG = "reaction";
+var TELEGRAM_ALLOWED_REACTIONS = /* @__PURE__ */ new Set([
+  "\u{1F44D}",
+  "\u{1F44E}",
+  "\u2764",
+  "\u{1F525}",
+  "\u{1F970}",
+  "\u{1F44F}",
+  "\u{1F601}",
+  "\u{1F914}",
+  "\u{1F92F}",
+  "\u{1F631}",
+  "\u{1F92C}",
+  "\u{1F622}",
+  "\u{1F389}",
+  "\u{1F929}",
+  "\u{1F92E}",
+  "\u{1F4A9}",
+  "\u{1F64F}",
+  "\u{1F44C}",
+  "\u{1F54A}",
+  "\u{1F921}",
+  "\u{1F971}",
+  "\u{1F974}",
+  "\u{1F60D}",
+  "\u{1F433}",
+  "\u2764\u{1F525}",
+  "\u{1F31A}",
+  "\u{1F32D}",
+  "\u{1F4AF}",
+  "\u{1F923}",
+  "\u26A1",
+  "\u{1F34C}",
+  "\u{1F3C6}",
+  "\u{1F494}",
+  "\u{1F928}",
+  "\u{1F610}",
+  "\u{1F353}",
+  "\u{1F37E}",
+  "\u{1F48B}",
+  "\u{1F595}",
+  "\u{1F608}",
+  "\u{1F634}",
+  "\u{1F62D}",
+  "\u{1F913}",
+  "\u{1F47B}",
+  "\u{1F468}\u{1F4BB}",
+  "\u{1F440}",
+  "\u{1F383}",
+  "\u{1F648}",
+  "\u{1F607}",
+  "\u{1F628}",
+  "\u{1F91D}",
+  "\u270D",
+  "\u{1F917}",
+  "\u{1FAE1}",
+  "\u{1F385}",
+  "\u{1F384}",
+  "\u2603",
+  "\u{1F485}",
+  "\u{1F92A}",
+  "\u{1F5FF}",
+  "\u{1F192}",
+  "\u{1F498}",
+  "\u{1F649}",
+  "\u{1F984}",
+  "\u{1F618}",
+  "\u{1F48A}",
+  "\u{1F64A}",
+  "\u{1F60E}",
+  "\u{1F47E}",
+  "\u{1F937}\u2642",
+  "\u{1F937}",
+  "\u{1F937}\u2640",
+  "\u{1F621}"
+]);
+var REACTION_FALLBACK_MAP = {
+  "\u{1F605}": "\u{1F923}",
+  "\u{1F602}": "\u{1F923}",
+  "\u{1F606}": "\u{1F601}",
+  "\u{1F604}": "\u{1F601}",
+  "\u{1F603}": "\u{1F601}",
+  "\u{1F642}": "\u{1F601}",
+  "\u{1F60A}": "\u{1F601}",
+  "\u263A": "\u{1F601}",
+  "\u{1F609}": "\u{1F601}",
+  "\u{1FAE0}": "\u{1F92A}",
+  "\u{1F61E}": "\u{1F622}",
+  "\u{1F614}": "\u{1F622}",
+  "\u{1F61F}": "\u{1F622}",
+  "\u{1F615}": "\u{1F914}",
+  "\u{1FAE4}": "\u{1F928}",
+  "\u{1F624}": "\u{1F621}",
+  "\u{1F620}": "\u{1F621}",
+  "\u{1F4AA}": "\u{1F44F}",
+  "\u{1F91E}": "\u{1F64F}",
+  "\u2705": "\u{1F44D}",
+  "\u274C": "\u{1F44E}",
+  "\u{1F62C}": "\u{1F648}",
+  "\u{1FAE3}": "\u{1F648}",
+  "\u{1F92D}": "\u{1F64A}",
+  "\u{1F480}": "\u{1F47B}"
+};
+function routeReaction(isAuthorized, chatType) {
+  if (!isAuthorized) return "discard";
+  if (chatType === "group" || chatType === "supergroup") return "buffer";
+  return "transport";
+}
+function formatReactionSignal(senderName, emojis) {
+  return `[${senderName} reaction: ${emojis.join(" ")}]`;
+}
+async function tryReaction(adapter, channelId, messageId, emoji, threadId, platform2) {
+  if (!adapter.setReaction || !messageId) {
+    await adapter.sendMessage(channelId, emoji, { threadId });
+    logDebug(TAG, `No reaction API \u2014 sent ${emoji} as text`);
+    return true;
+  }
+  if (platform2 && platform2 !== "telegram") {
+    try {
+      await adapter.setReaction(channelId, messageId, emoji);
+      logDebug(TAG, `Reaction: ${emoji}`);
+      return true;
+    } catch {
+      await adapter.sendMessage(channelId, emoji, { threadId });
+      return true;
+    }
+  }
+  const fallback = TELEGRAM_ALLOWED_REACTIONS.has(emoji) ? emoji : REACTION_FALLBACK_MAP[emoji] ?? null;
+  if (fallback) {
+    try {
+      await adapter.setReaction(channelId, messageId, fallback);
+      logDebug(TAG, `Reaction: ${emoji}${emoji !== fallback ? ` \u2192 ${fallback}` : ""}`);
+      return true;
+    } catch (err) {
+      logAndSwallow("reactions", "op", err);
+    }
+  }
+  await adapter.sendMessage(channelId, emoji, { threadId });
+  logDebug(TAG, `Reaction ${emoji} not supported \u2014 sent as text`);
+  return true;
+}
+
+// src/components/tts.ts
+var import_edge_tts = __toESM(require_dist(), 1);
+init_logger();
+var MAX_TTS_CHARS = 4e3;
+var DEFAULT_VOICE_MAP = {
+  hu: "hu-HU-TamasNeural",
+  en: "en-US-AndrewMultilingualNeural"
+};
+function extractLangTag(text) {
+  const m = text.match(/^\[lang:(\w{2})\]\s*/i);
+  if (m) return { lang: m[1].toLowerCase(), text: text.slice(m[0].length) };
+  return { lang: null, text };
+}
+async function synthesizeSpeech(text, config) {
+  const { lang, text: stripped } = extractLangTag(text);
+  const cleaned = cleanForTts(stripped).trim();
+  if (!cleaned || cleaned.length < 5) {
+    logDebug("tts", `Text too short for TTS (${cleaned.length} chars)`);
+    return null;
+  }
+  const voiceMap = { ...DEFAULT_VOICE_MAP, ...config.voiceMap };
+  const voice = lang && voiceMap[lang] || config.voice;
+  const input = cleaned.length > MAX_TTS_CHARS ? cleaned.slice(0, MAX_TTS_CHARS) + "... (truncated)" : cleaned;
+  logInfo("tts", `Synthesizing ${input.length} chars with voice ${voice}${lang ? ` (lang:${lang})` : ""}`);
+  try {
+    const tts = new import_edge_tts.EdgeTTS();
+    await tts.synthesize(input, voice, {
+      rate: "+0%",
+      pitch: "+0Hz",
+      outputFormat: import_edge_tts.Constants.OUTPUT_FORMAT.WEBM_24KHZ_16BIT_MONO_OPUS
+    });
+    const audioBuffer = tts.toBuffer();
+    if (!audioBuffer || audioBuffer.length === 0) {
+      logWarn("tts", "Edge TTS returned empty audio");
+      return null;
+    }
+    logInfo("tts", `Audio generated: ${audioBuffer.length} bytes`);
+    return audioBuffer;
+  } catch (err) {
+    logWarn("tts", `TTS synthesis failed: ${err instanceof Error ? err.message : String(err)}`);
+    return null;
+  }
+}
+function cleanForTts(text) {
+  let result = text.replace(/<br\s*\/?>/gi, "\n").replace(/<[^>]+>/g, "").replace(/^.*\(using tool:\s*\w+\).*$/gm, "").replace(/^.*\[mode:.*$/gm, "").replace(/^(Fetching content from|Searching the web|Searching for|Reading file|Writing to|Running command|Executing|Looking at|Checking).*$/gm, "").replace(/^(Let me|I'll|I will|I need to|I'm going to|I should)\b.*$/gm, "").replace(/^- Completed in \d+(\.\d+)?s.*$/gm, "").replace(/^WARNING:.*$/gm, "").replace(/^https?:\/\/\S+$/gm, "").replace(/^\s*\[.*?\]\s*$/gm, "").replace(/```[\s\S]*?```/g, " (code block omitted) ").replace(/`[^`]+`/g, "").replace(/\[([^\]]+)\]\([^)]+\)/g, "$1").replace(/[*_~]{1,3}/g, "").replace(/^#{1,6}\s+/gm, "").replace(/^[-*+]\s+/gm, "").replace(/^\d+\.\s+/gm, "");
+  try {
+    result = result.replace(/\p{Extended_Pictographic}/gu, "");
+  } catch (err) {
+    logWarn("tts", `Emoji filter failed, using unfiltered text: ${err instanceof Error ? err.message : String(err)}`);
+  }
+  return result.replace(/\n{3,}/g, "\n\n").trim();
+}
+
+// src/components/sanitize-outbound.ts
+var STRIP = [
+  /\s*\[TOPICS:\s*.+?\]/gi,
+  /\s*\[NO_REPLY\]\s*/gi,
+  /\s*\[REACT:.+?\]\s*/gi
+];
+function sanitizeOutbound(text) {
+  let out = text;
+  for (const re of STRIP) {
+    re.lastIndex = 0;
+    out = out.replace(re, "");
+  }
+  return out.trim();
+}
+
+// src/components/pipeline/middleware.ts
+async function runPipeline(ctx, middlewares) {
+  let index = 0;
+  const next = async () => {
+    if (ctx.handled || index >= middlewares.length) return;
+    const mw = middlewares[index++];
+    await mw(ctx, next);
+  };
+  await next();
+}
+function createMessageContext(msg, adapter, deps) {
+  const reply = (text, opts) => {
+    const clean = sanitizeOutbound(text);
+    if (!clean) return Promise.resolve(void 0);
+    return adapter.sendMessage(msg.channelId, clean, { threadId: msg.threadId, ...opts });
+  };
+  const chatId = parseInt(msg.channelId, 10) || 0;
+  const userId = msg.userId;
+  return {
+    msg,
+    adapter,
+    deps,
+    text: msg.text,
+    chatId,
+    userId,
+    reply,
+    handled: false
+  };
+}
+
+// src/components/pipeline/voice.ts
+init_logger();
+var voiceMiddleware = async (ctx, next) => {
+  const { msg, adapter, deps } = ctx;
+  if (msg.isVoice && msg.voiceFileId && adapter.downloadVoice && deps.sttConfig) {
+    try {
+      if (adapter.setReaction && msg.messageId) {
+        await adapter.setReaction(msg.channelId, msg.messageId, "\u{1F440}");
+      }
+      const audioBuffer = await adapter.downloadVoice(msg.voiceFileId);
+      const { text: transcript, language } = await transcribeAudio(audioBuffer, "voice.ogg", deps.sttConfig);
+      if (!transcript) {
+        if (adapter.setReaction && msg.messageId) await adapter.setReaction(msg.channelId, msg.messageId, "");
+        await ctx.reply("\u{1F937} Couldn't transcribe the voice note.");
+        ctx.handled = true;
+        return;
+      }
+      const langTag = language ? `, ${language}` : "";
+      ctx.text = `[\u{1F3A4} voice${langTag}] ${transcript}`;
+    } catch (err) {
+      logError("voice-mw", "Voice transcription failed", err);
+      if (adapter.setReaction && msg.messageId) await adapter.setReaction(msg.channelId, msg.messageId, "");
+      await ctx.reply("\u274C Voice transcription failed.");
+      ctx.handled = true;
+      return;
+    }
+  } else if (msg.isVoice && !deps.sttConfig) {
+    await ctx.reply("\u{1F3A4} Voice notes require STT (set GROQ_API_KEY).");
+    ctx.handled = true;
+    return;
+  }
+  await next();
+};
+
+// src/components/pipeline/commands.ts
+init_logger();
+var BANG_PREFIX = /^[!！ǃ❗❕‼⁉]+/u;
+var INTERRUPT_COMMANDS = /* @__PURE__ */ new Set(["/stop", "/ctrlc", "/new", "/reset", "/restart"]);
+var DESTRUCTIVE_COMMANDS = /* @__PURE__ */ new Set(["/stop", "/ctrlc", "/new", "/reset", "/restart", "/compact", "/coding", "/default"]);
+var commandMiddleware = async (ctx, next) => {
+  const { msg, deps } = ctx;
+  const {
+    transport,
+    config,
+    startedAt,
+    memory,
+    memoryConfig,
+    nlmConfig,
+    idleSave,
+    sessions,
+    sessionManager,
+    updateCtxStart,
+    conversationBuffer
+  } = deps;
+  const registry = loadUsers();
+  const resolvedUserId = msg.userId;
+  const user = registry.byUserId.get(resolvedUserId);
+  const isMaster = user?.role === "master";
+  if (!isMaster && BANG_PREFIX.test(ctx.text)) {
+    const original = ctx.text;
+    ctx.text = ctx.text.replace(BANG_PREFIX, "");
+    logInfo("commands", `Defanged bang prefix from ${user?.userId ?? "unknown"}: "${original.slice(0, 25)}"`);
+    if (!ctx.text.trim()) {
+      ctx.handled = true;
+      return;
+    }
+  }
+  const trimmed = ctx.text.trim();
+  const cmd = trimmed.split(/\s/)[0].toLowerCase();
+  const activeId = sessionManager.getActiveSessionId(msg.userId, msg.platform);
+  if (INTERRUPT_COMMANDS.has(cmd) && sessions.get(activeId)?.busy) {
+    logInfo("commands", `Interrupt command ${cmd} while busy \u2014 stopping current response`);
+    await transport.sendInterrupt();
+    sessions.getOrCreate(activeId).busy = false;
+  }
+  if (!INTERRUPT_COMMANDS.has(cmd) && DESTRUCTIVE_COMMANDS.has(cmd) && sessions.get(activeId)?.busy) {
+    const deferredWording = {
+      "/compact": "\u23F3 Will /compact after current response finishes.",
+      "/coding": "\u23F3 Will switch to coding mode after current response finishes.",
+      "/default": "\u23F3 Will switch to default mode after current response finishes."
+    };
+    const specific = deferredWording[cmd];
+    if (specific) {
+      await ctx.reply(specific);
+      ctx.deferReply = true;
+    }
+    await next();
+    return;
+  }
+  const { adapter } = ctx;
+  const editReply = adapter.editMessage ? async (messageId, text) => {
+    await adapter.editMessage(msg.channelId, messageId, text);
+  } : void 0;
+  const cmdCtx = {
+    sessionKey: activeId,
+    chatId: ctx.chatId,
+    userId: ctx.userId ?? "master",
+    platform: msg.platform,
+    reply: ctx.reply,
+    editReply,
+    transport,
+    config,
+    startedAt,
+    memory,
+    memoryConfig,
+    nlmConfig,
+    idleSave,
+    sessions,
+    sessionManager: deps.sessionManager,
+    updateCtxStart,
+    cronCurrentJob: deps.cronCurrentJob?.() ?? null,
+    enqueueCron: deps.enqueueCron,
+    requestShutdown: deps.requestShutdown,
+    sleepProgress: deps.sleepProgress,
+    loadedCapabilities: deps.loadedCapabilities,
+    selfHealerTask: deps.selfHealerTask,
+    hailMary: deps.hailMary,
+    rebuildTransport: deps.rebuildTransport,
+    phaseHealth: deps.phaseHealth,
+    registry: deps.registry,
+    bridgeLockPath: deps.bridgeLockPath,
+    conversationBuffer: msg.isGroup ? conversationBuffer : void 0,
+    bufKey: msg.isGroup ? `${msg.platform}:${msg.channelId}` : void 0
+  };
+  if (await handleCommand(ctx.text, cmdCtx)) {
+    ctx.handled = true;
+    return;
+  }
+  if (ctx.text.startsWith("//")) {
+    ctx.text = ctx.text.slice(1);
+  }
+  if (transport.transportCommands.includes(cmd) && transport.executeCommand) {
+    const result = await transport.executeCommand(ctx.text);
+    await ctx.reply(result);
+    ctx.handled = true;
+    return;
+  }
+  await next();
+};
+
+// src/components/pipeline/busy-guard.ts
+init_logger();
+var MAX_QUEUE_DEPTH = 20;
+var busyGuardMiddleware = async (ctx, next) => {
+  const { msg, adapter, deps } = ctx;
+  const userId = msg.userId;
+  const activeId = deps.sessionManager.getActiveSessionId(userId, msg.platform);
+  const entry = deps.sessions.getOrCreate(activeId);
+  if (entry.busy) {
+    const text = ctx.text.trim();
+    const lower = text.toLowerCase();
+    if (lower === "/stop" || lower === "/ctrlc") {
+      logInfo("busy-guard", `STOP interrupt for ${activeId}`);
+      await deps.transport.sendInterrupt();
+      entry.busy = false;
+      try {
+        await adapter.sendMessage(msg.channelId, "\u{1F6D1} Stopped.", { threadId: msg.threadId });
+      } catch {
+      }
+      ctx.handled = true;
+      return;
+    }
+    if (lower.startsWith("/wait") || lower.startsWith("/steer")) {
+      const body = text.replace(/^\/(wait|steer)\s*/i, "").trim();
+      const steer = body ? `[USER] Wait! ${body}` : "[USER] Wait!";
+      entry.pendingWait = entry.pendingWait ? entry.pendingWait + "\n" + steer : steer;
+      logInfo("busy-guard", `Steer queued for ${activeId}: "${body || "(no message)"}"`);
+      try {
+        await adapter.sendMessage(msg.channelId, "\u{1F4CC} Noted.", { threadId: msg.threadId });
+      } catch {
+      }
+      ctx.handled = true;
+      return;
+    }
+    if (lower === "wait") {
+      logInfo("busy-guard", `Legacy WAIT interrupt for ${activeId}`);
+      await deps.transport.sendInterrupt();
+      entry.busy = false;
+      try {
+        await adapter.sendMessage(msg.channelId, "\u{1F6D1} Stopped.", { threadId: msg.threadId });
+      } catch {
+      }
+      ctx.handled = true;
+      return;
+    }
+    if (entry.queue.length >= MAX_QUEUE_DEPTH) {
+      const dropped = entry.queue.length - MAX_QUEUE_DEPTH + 1;
+      entry.queue.splice(0, dropped);
+      logWarn("busy-guard", `Queue overflow for ${activeId} \u2014 dropped ${dropped} oldest message(s)`);
+    }
+    entry.queue.push({ msg, adapter });
+    logDebug("busy-guard", `Queued "${ctx.text.slice(0, 40)}" for ${activeId} (${entry.queue.length} pending)`);
+    if (!ctx.deferReply) {
+      if (entry.compacting) {
+        try {
+          await adapter.sendMessage(msg.channelId, "\u2615 Hold on, just tidying up my thoughts over coffee... I'll get to you in a moment!", { threadId: msg.threadId });
+        } catch {
+        }
+      }
+      logDebug("busy-guard", `Queue: ${entry.compacting ? "compacting" : `queued (${entry.queue.length})`} for ${activeId}`);
+    }
+    ctx.handled = true;
+    return;
+  }
+  await next();
+};
+
+// src/components/pipeline/prompt-builder.ts
+init_log_and_swallow();
+init_logger();
+
+// src/components/message-interceptor.ts
+init_paths();
+init_logger();
+import { mkdirSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+var TAG2 = "MessageInterceptor";
+var OVERFLOW_DIR = join(abtarsHome(), "overflow");
+var DEFAULT_THRESHOLD = 8e3;
+var PREVIEW_LENGTH = 500;
+function interceptLargeMessage(text, threshold = DEFAULT_THRESHOLD) {
+  if (text.length <= threshold) {
+    return { text, intercepted: false };
+  }
+  mkdirSync(OVERFLOW_DIR, { recursive: true });
+  const filename = `overflow_${Date.now()}.md`;
+  const filePath = join(OVERFLOW_DIR, filename);
+  writeFileSync(filePath, text, "utf-8");
+  const preview = text.slice(0, PREVIEW_LENGTH);
+  const replaced = `${preview}
+
+---
+\u26A0\uFE0F Message truncated (${text.length} chars). Full content saved to: ${filePath}`;
+  logInfo(TAG2, `Intercepted oversized message (${text.length} chars) \u2192 ${filePath}`);
+  return { text: replaced, intercepted: true, filePath };
+}
+
+// src/components/pipeline/prompt-builder.ts
+init_env_schema();
+var TAG3 = "pipeline";
+var ACTIVE_MEMORY_LIMIT = 5;
+async function buildPrompt(msg, text, deps, registry) {
+  const { memory, sessions, conversationBuffer, contextPercent } = deps;
+  const { channelId, isGroup } = msg;
+  const userId = msg.userId;
+  const sessionKey = deps.sessionManager.getActiveSessionId(userId, msg.platform);
+  const bufKey = `${msg.platform}:${channelId}`;
+  let prompt = `[${localTime()}] ${text}`;
+  let imageContent;
+  if (msg.mediaPath) {
+    if (deps.isAcp) {
+      prompt += `
+Image saved at: ${msg.mediaPath}`;
+    } else {
+      const { readFileSync: readFileSync3 } = await import("node:fs");
+      const ext = msg.mediaPath.split(".").pop()?.toLowerCase();
+      const visionMimes = { jpg: "image/jpeg", jpeg: "image/jpeg", png: "image/png", gif: "image/gif", webp: "image/webp" };
+      const mime = ext ? visionMimes[ext] : void 0;
+      if (mime) {
+        try {
+          const buf = readFileSync3(msg.mediaPath);
+          const b64 = buf.toString("base64");
+          const maxCtxPct = parseInt(process.env["IMAGE_MAX_CONTEXT_PCT"] ?? "30", 10);
+          const maxContext = deps.maxContext ?? 128e3;
+          const imgTokens = Math.ceil(b64.length / 4);
+          if (imgTokens <= maxContext * (maxCtxPct / 100)) {
+            imageContent = { mime, base64: b64, path: msg.mediaPath };
+          } else {
+            prompt += `
+\u26A0\uFE0F Image too large. Saved at: ${msg.mediaPath}`;
+          }
+        } catch {
+          prompt += `
+File saved at: ${msg.mediaPath}`;
+        }
+      } else {
+        prompt += `
+File saved at: ${msg.mediaPath}`;
+      }
+    }
+  }
+  if (isGroup) {
+    const context = conversationBuffer.drain(bufKey);
+    if (context) {
+      prompt = context + text;
+      logDebug(TAG3, "Prepended group context to prompt");
+    }
+  }
+  const entry = sessions.getOrCreate(sessionKey);
+  const isSessionStart = entry.pendingStart || !entry.seen;
+  logTrace(TAG3, `session-state: key=${sessionKey} seen=${entry.seen} pendingStart=${entry.pendingStart} isSessionStart=${isSessionStart}`);
+  if (isSessionStart && memory) {
+    prompt = buildSessionStartPrompt(prompt, memory, userId, sessionKey, deps.maxContext);
+  }
+  entry.seen = true;
+  entry.pendingStart = false;
+  const userRole = registry.byUserId.get(userId)?.role;
+  if (memory && userRole !== "guest") {
+    const numericMsgId = typeof msg.messageId === "number" ? msg.messageId : void 0;
+    memory.recordMessage({ role: "user", content: text, timestamp: Date.now(), userId, sessionId: sessionKey, platformMessageId: numericMsgId });
+  }
+  if (getEnv().activeMemory && memory) {
+    const userEntry = registry.byUserId.get(userId);
+    if (userEntry?.role !== "guest" && (contextPercent < 0 || contextPercent < getEnv().ctxCompactPct)) {
+      try {
+        const t0 = performance.now();
+        const priming = sessions.get(sessionKey)?.primingTerms ?? [];
+        const now = /* @__PURE__ */ new Date();
+        const recall = await memory.recallSearch({
+          translated: [.../* @__PURE__ */ new Set([text, ...priming])],
+          original: text,
+          userId,
+          limit: ACTIVE_MEMORY_LIMIT,
+          maxClassification: userEntry?.maxClass ?? 0,
+          stages: ["Sf", "Ss"],
+          currentContext: { hour: now.getHours(), dayOfWeek: now.getDay() }
+        });
+        const TRIVIAL_TTL_MS = 36 * 60 * 6e4;
+        const nowMs = Date.now();
+        const hits = recall.results.filter((h) => {
+          if (h.score <= 0.7) return false;
+          if (h.memoryType === "fact" && h.score < 1 && h.createdAt && nowMs - h.createdAt > TRIVIAL_TTL_MS) {
+            if (!h.emotionTags && !h.importanceFlags) return false;
+          }
+          return true;
+        });
+        if (hits.length > 0) {
+          const lines = hits.map((h) => abmind().renderMemory({
+            content_en: h.content,
+            topic: h.topic ?? void 0,
+            emotion_tags: h.emotionTags ?? void 0,
+            importance_flags: h.importanceFlags ?? void 0,
+            memory_type: h.memoryType ?? void 0,
+            confidence: h.confidence ?? void 0,
+            createdAt: h.createdAt
+          }));
+          const block = `[MEMORY CONTEXT \u2014 auto-recalled, do not repeat verbatim]
+${lines.join("\n")}
+[/MEMORY CONTEXT]
+
+`;
+          prompt = block + prompt;
+          logDebug(TAG3, `Active recall: ${hits.length} hits, ${block.length} chars, ${Math.round(performance.now() - t0)}ms`);
+          logTrace(TAG3, `recall content: ${block}`);
+        }
+      } catch (err) {
+        logDebug(TAG3, `Active recall failed: ${err instanceof Error ? err.message : String(err)}`);
+      }
+    }
+  }
+  if (!isSessionStart) {
+    prompt = interceptLargeMessage(prompt).text;
+  }
+  if (userRole !== "master" && text.length > 10) {
+    const scanForInjection = abmind().scanForInjection;
+    const scan = scanForInjection(text);
+    if (!scan.safe) {
+      logInfo(TAG3, `Injection blocked from ${userId}: ${scan.flags.map((f) => f.category).join(", ")}`);
+      return { prompt: "__INJECTION_BLOCKED__", isSessionStart, imageContent: void 0 };
+    }
+  }
+  return { prompt, isSessionStart, imageContent };
+}
+function buildSessionStartPrompt(prompt, memory, userId, sessionKey, maxContext) {
+  const contextParts = [];
+  const reason = readAndClearRestartReason();
+  if (reason) {
+    contextParts.push(`[SESSION START REASON] ${reason}`);
+    logInfo(TAG3, `Injected restart reason: ${reason}`);
+  }
+  let sessionType = "A";
+  if (sessionKey) {
+    const parts = sessionKey.split("_");
+    if (parts.length === 3) {
+      sessionType = parts[1];
+      const typeMap = { A: "Main", B: "Browse", C: "Code", T: "Task" };
+      const type = typeMap[sessionType] ?? sessionType;
+      const index = parseInt(parts[2], 10);
+      contextParts.push(`[SESSION] #${index} (${type})`);
+    }
+  }
+  const isCodeSession = sessionType === "C";
+  if (isCodeSession) {
+    const minimal = loadMinimalSoul(memory);
+    if (minimal) {
+      contextParts.push(minimal);
+      logInfo(TAG3, `Injected minimal soul for Code session (${minimal.length} chars)`);
+    }
+  } else {
+    const soul = loadSoulBundle(memory);
+    if (soul) {
+      contextParts.push(soul);
+      logInfo(TAG3, `Injected soul bundle (${soul.length} chars)`);
+    } else {
+      contextParts.push("[\u26A0\uFE0F SOUL BUNDLE MISSING] Your persona files failed to load. Alert the user immediately and request a /reset.");
+      logWarn(TAG3, "Soul bundle empty \u2014 injected missing-soul warning");
+    }
+  }
+  if (sessionKey) {
+    try {
+      const registry = loadUsers();
+      const user = registry.byUserId.get(userId);
+      if (user) {
+        const CLASS_NAMES = ["UNCLASSIFIED", "RESTRICTED", "CONFIDENTIAL", "SECRET"];
+        const lang = user.languages?.length ? `
+Their languages: ${user.languages.join(", ")}. Respond ONLY in these languages.` : "";
+        const userBlock = `[CURRENT USER]
+You are now talking to ${user.userId} (${user.role}, ${CLASS_NAMES[user.maxClass] ?? `class ${user.maxClass}`} clearance).${lang}`;
+        contextParts.push(userBlock);
+        logInfo(TAG3, `Injected [CURRENT USER] for ${user.userId} (${user.role})`);
+      } else {
+        logInfo(TAG3, `[CURRENT USER] skipped \u2014 userId "${userId}" not found in registry (${registry.byUserId.size} users loaded)`);
+      }
+    } catch (err) {
+      logAndSwallow("prompt_builder", "op", err);
+    }
+  } else {
+    logInfo(TAG3, `[CURRENT USER] skipped \u2014 no sessionKey`);
+  }
+  const compSummary = null;
+  if (compSummary && sessionKey) {
+  } else {
+    const ctxOpts = isCodeSession ? { skipDailies: true, maxAgeMs: 48 * 60 * 60 * 1e3 } : void 0;
+    const ctx = abmind()?.buildSessionStartContext(memory, userId, maxContext, ctxOpts);
+    if (ctx) {
+      contextParts.push(ctx);
+      logInfo(TAG3, `Injected session-start context (${ctx.length} chars${isCodeSession ? ", Code mode" : ""})`);
+      logTrace(TAG3, `session-start content: ${ctx}`);
+    }
+    try {
+      const userRole = loadUsers().byUserId.get(userId)?.role ?? "master";
+      if (userRole === "guest") {
+        contextParts.push("Hi! How can I help?");
+      } else if (userRole === "user") {
+        contextParts.push("[SESSION START] Returning user. Be friendly and helpful.");
+      } else if (!isCodeSession) {
+        const wakeUp = memory.buildWakeUp();
+        if (wakeUp) {
+          contextParts.push(wakeUp);
+          logInfo(TAG3, `Injected ABM wake-up (${wakeUp.length} chars)`);
+          logTrace(TAG3, `wake-up content: ${wakeUp}`);
+        }
+        if (sessionKey && !sessionKey.includes("_C_")) {
+          const status = abmind().buildStatusBlock(memory);
+          if (status) contextParts.push(status);
+        }
+      }
+    } catch (err) {
+      logAndSwallow("prompt_builder", "op", err);
+    }
+  }
+  const contextBlock = contextParts.length > 0 ? `[CONTEXT \u2014 do not respond to this section]
+${contextParts.join("\n\n")}
+[/CONTEXT]
+
+` : "";
+  const result = contextBlock + prompt;
+  logTrace(TAG3, `session-start assembled: ${contextParts.length} parts, context=${contextBlock.length} chars, prompt=${prompt.length} chars, total=${result.length} chars`);
+  if (result.length < 5e3) {
+    logInfo(TAG3, `Session-start prompt suspiciously small (${result.length} chars) \u2014 SOUL may be missing`);
+  }
+  if (maxContext && contextBlock.length > maxContext * 0.15) {
+    logWarn(TAG3, `\u26A0\uFE0F Session injection is ${Math.round(contextBlock.length / maxContext * 100)}% of context window \u2014 consider reducing SESSION_HISTORY_PCT`);
+  }
+  return result;
+}
+
+// src/components/message-pipeline.ts
+init_env_schema();
+
+// src/components/session-registry.ts
+function createEntry() {
+  return {
+    busy: false,
+    queue: [],
+    fullMode: false,
+    pendingStart: false,
+    seen: false,
+    compacting: false,
+    ctxWarned: false,
+    compactFailures: 0,
+    primingTerms: [],
+    lastActiveAt: Date.now()
+  };
+}
+var SessionRegistry = class {
+  entries = /* @__PURE__ */ new Map();
+  get(key) {
+    return this.entries.get(key);
+  }
+  getOrCreate(key) {
+    let entry = this.entries.get(key);
+    if (!entry) {
+      entry = createEntry();
+      this.entries.set(key, entry);
+    }
+    entry.lastActiveAt = Date.now();
+    return entry;
+  }
+  delete(key) {
+    this.entries.delete(key);
+  }
+  /** Mark every tracked session as needing session-start injection on its next message. */
+  has(key) {
+    return this.entries.has(key);
+  }
+  keys() {
+    return this.entries.keys();
+  }
+  get size() {
+    return this.entries.size;
+  }
+  /** JSON-serializable snapshot for dashboard. */
+  snapshot() {
+    return Object.fromEntries(this.entries);
+  }
+  /** Remove idle entries older than maxAgeMs. Returns count pruned. */
+  prune(maxAgeMs) {
+    const cutoff = Date.now() - maxAgeMs;
+    let pruned = 0;
+    for (const [key, entry] of this.entries) {
+      if (entry.lastActiveAt < cutoff && !entry.busy && !entry.compacting && entry.queue.length === 0) {
+        this.entries.delete(key);
+        pruned++;
+      }
+    }
+    return pruned;
+  }
+};
+
+// src/components/message-pipeline.ts
+async function retrySend(fn, attempts = 3) {
+  for (let i = 0; i < attempts; i++) {
+    try {
+      return await fn();
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      const transient = msg.includes("fetch failed") || msg.includes("ETIMEDOUT") || msg.includes("ECONNRESET") || /^5\d\d/.test(msg);
+      if (!transient || i === attempts - 1) throw err;
+      const delay = 1e3 * Math.pow(3, i);
+      logWarn("pipeline", `Delivery failed (attempt ${i + 1}/${attempts}), retrying in ${delay}ms: ${msg}`);
+      await new Promise((r) => setTimeout(r, delay));
+    }
+  }
+  throw new Error("unreachable");
+}
+var TAG4 = "pipeline";
+var PRIMING_MAX = 8;
+var STOPWORDS = /* @__PURE__ */ new Set([
+  "the",
+  "a",
+  "an",
+  "is",
+  "are",
+  "was",
+  "were",
+  "be",
+  "been",
+  "have",
+  "has",
+  "had",
+  "do",
+  "does",
+  "did",
+  "will",
+  "would",
+  "could",
+  "should",
+  "can",
+  "may",
+  "might",
+  "shall",
+  "it",
+  "its",
+  "this",
+  "that",
+  "what",
+  "how",
+  "when",
+  "where",
+  "who",
+  "which",
+  "why",
+  "about",
+  "for",
+  "with",
+  "from",
+  "into",
+  "just",
+  "also",
+  "very",
+  "not",
+  "but",
+  "and",
+  "or",
+  "if",
+  "so",
+  "too",
+  "let",
+  "lets",
+  "dont",
+  "you",
+  "we",
+  "my",
+  "your",
+  "our",
+  "me",
+  "us",
+  "them",
+  "they",
+  "he",
+  "she"
+]);
+function extractKeywords(text) {
+  return text.toLowerCase().replace(/[^\p{L}\p{N}\s]/gu, " ").split(/\s+/).filter((w) => w.length >= 3 && !STOPWORDS.has(w)).slice(0, 3);
+}
+var resetIdleCompactFlag = null;
+function setIdleCompactReset(fn) {
+  resetIdleCompactFlag = fn;
+}
+async function resetAndPrepare(opts) {
+  await opts.transport.resetSession(opts.sessionKey);
+  if (opts.conversationBuffer && opts.bufKey) opts.conversationBuffer.clear(opts.bufKey);
+  opts.sessions.delete(opts.sessionKey);
+  opts.sessions.getOrCreate(opts.sessionKey).pendingStart = true;
+  const t = opts.transport;
+  t.setEmergencyMode?.(null);
+}
+async function handleInboundMessage(msg, adapter, deps) {
+  const ctx = createMessageContext(msg, adapter, deps);
+  await runPipeline(ctx, [voiceMiddleware, commandMiddleware, busyGuardMiddleware]);
+  if (ctx.handled) return;
+  if (hasHooks("BeforeMessage")) {
+    const result = await fire("BeforeMessage", {
+      event: "BeforeMessage",
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      sessionKey: "",
+      platform: msg.platform,
+      userId: msg.userId,
+      chatId: String(ctx.chatId),
+      text: ctx.text
+    });
+    if (result?.decision === "block") {
+      logInfo(TAG4, `BeforeMessage hook blocked: ${result.reason ?? "no reason"}`);
+      return;
+    }
+  }
+  const {
+    transport,
+    memory,
+    memoryConfig,
+    idleSave,
+    conversationBuffer,
+    ttsConfig,
+    sessions
+  } = deps;
+  const { channelId, isVoice } = msg;
+  const chatId = ctx.chatId;
+  const text = ctx.text;
+  const registry = loadUsers();
+  const userId = msg.userId;
+  const activeSessionId = deps.sessionManager.getActiveSessionId(userId, msg.platform);
+  const busyEntry = sessions.getOrCreate(activeSessionId);
+  let typingInterval;
+  let typingTtlTimer;
+  let toolElapsedTimer;
+  let streamMsgId;
+  try {
+    busyEntry.busy = true;
+    resetIdleCompactFlag?.();
+    const ctxPct = transport.contextPercent;
+    logInfo(TAG4, `\u2190 [${msg.platform}] ${isVoice ? "\u{1F3A4} " : ""}"${text.slice(0, 60)}"${ctxPct >= 0 ? ` (ctx: ${ctxPct}%)` : ""}`);
+    const { prompt: builtPrompt, imageContent } = await buildPrompt(msg, text, {
+      memory,
+      memoryConfig,
+      sessions,
+      sessionManager: deps.sessionManager,
+      conversationBuffer,
+      contextPercent: ctxPct,
+      maxContext: deps.maxContext,
+      isAcp: !("agentLoop" in transport)
+    }, registry);
+    if (builtPrompt === "__INJECTION_BLOCKED__") {
+      await adapter.sendMessage(channelId, "\u26D4 Message blocked \u2014 suspicious content detected.", { threadId: msg.threadId });
+      return;
+    }
+    let prompt = builtPrompt;
+    const { drainCompletions } = await import("./completion-buffer-S3LXDZG2.js");
+    const completions = drainCompletions(activeSessionId);
+    if (completions.length > 0) {
+      const notes = completions.map((c) => {
+        const cost = c.inputTokens + c.outputTokens > 0 ? ` [${((c.inputTokens + c.outputTokens) / 1e3).toFixed(1)}k tokens]` : "";
+        return `[SYSTEM] Background session ${c.sessionId} ${c.status}
+Goal: ${c.goal}
+Result: ${c.result}${cost}`;
+      }).join("\n\n");
+      prompt = `${notes}
+
+---
+
+${prompt}`;
+    }
+    const activeSession = deps.sessionManager.getActiveSession(userId, msg.platform);
+    const agentSession = activeSession.agentSession;
+    logDebug(TAG4, `Route: session=${activeSessionId} type=${activeSession.type} agentSession=${agentSession ? "yes" : "no"}`);
+    if ("sandboxPolicy" in transport) {
+      const { buildPolicy } = await import("./tool-sandbox-OZMXJZLQ.js");
+      transport.sandboxPolicy = buildPolicy("owner");
+    }
+    if ("isPaused" in transport) {
+      transport.isPaused = () => activeSession.paused;
+    }
+    if ("getPendingInstruction" in transport) {
+      const sessionEntry = deps.sessions.getOrCreate(activeSessionId);
+      transport.getPendingInstruction = () => {
+        const pending = sessionEntry.pendingWait;
+        if (!pending) return void 0;
+        sessionEntry.pendingWait = void 0;
+        return pending;
+      };
+    }
+    const responsePromise = agentSession ? agentSession.sendPrompt(activeSessionId, prompt, imageContent) : transport.sendPrompt(activeSessionId, prompt, imageContent, userId);
+    if (!isVoice && adapter.setReaction && msg.messageId) {
+      await adapter.setReaction(channelId, msg.messageId, "\u{1F440}");
+    }
+    if (adapter.sendTyping) {
+      await adapter.sendTyping(channelId, msg.threadId);
+      typingInterval = setInterval(() => {
+        adapter.sendTyping(channelId, msg.threadId).catch((err) => logAndSwallow(TAG4, "adapter call", err));
+      }, 8e3);
+    }
+    const TYPING_TTL_MS = getEnv().typingTtlMs;
+    typingTtlTimer = setTimeout(() => {
+      if (typingInterval) {
+        clearInterval(typingInterval);
+        typingInterval = void 0;
+      }
+    }, TYPING_TTL_MS);
+    let lastToolNotifyAt = 0;
+    let toolBatch = [];
+    let toolBatchTimer;
+    let currentToolName = "";
+    let toolStartAt = 0;
+    let toolCallCount = 0;
+    let totalToolStartAt = 0;
+    transport.onToolCallStart = (toolName) => {
+      toolCallCount++;
+      if (!totalToolStartAt) totalToolStartAt = Date.now();
+      currentToolName = toolName;
+      toolStartAt = Date.now();
+      adapter.sendTyping?.(channelId, msg.threadId).catch((err) => logAndSwallow(TAG4, "adapter call", err));
+      if (toolElapsedTimer) {
+        clearInterval(toolElapsedTimer);
+        toolElapsedTimer = void 0;
+      }
+      toolBatch.push(toolName);
+      if (!toolBatchTimer) {
+        toolBatchTimer = setTimeout(async () => {
+          const now = Date.now();
+          if (now - lastToolNotifyAt >= 1e4) {
+            const names = toolBatch.join(", ");
+            const status = `\u{1F527} ${names}...`;
+            if (streamMsgId && adapter.editMessage) {
+              adapter.editMessage(channelId, streamMsgId, status + "...").catch((err) => logAndSwallow(TAG4, "adapter call", err));
+            } else {
+              const id = await adapter.sendMessage(channelId, status, { threadId: msg.threadId }).catch((err) => {
+                logAndSwallow(TAG4, "sendMessage tool status", err);
+                return void 0;
+              });
+              if (id && adapter.editMessage) streamMsgId = id;
+            }
+            lastToolNotifyAt = now;
+          }
+          toolBatch = [];
+          toolBatchTimer = void 0;
+        }, 500);
+      }
+      toolElapsedTimer = setInterval(() => {
+        const elapsed = Math.round((Date.now() - toolStartAt) / 1e3);
+        const elapsedStr = elapsed >= 60 ? `${Math.floor(elapsed / 60)}m${elapsed % 60}s` : `${elapsed}s`;
+        const status = `\u{1F527} ${currentToolName} (${elapsedStr})...`;
+        if (streamMsgId && adapter.editMessage) {
+          adapter.editMessage(channelId, streamMsgId, status + "...").catch((err) => logAndSwallow(TAG4, "adapter call", err));
+        }
+      }, 1e4);
+    };
+    if ("onFallback" in transport) {
+      const prev = transport.onFallback;
+      transport.onFallback = (model, _ctxPct, reason) => {
+        prev?.(model, _ctxPct, reason);
+      };
+    }
+    let fullResponseSegments = [];
+    transport.onSegmentBreak = (text2) => {
+      fullResponseSegments.push(text2);
+      if (streamMsgId && adapter.editMessage) {
+        adapter.editMessage(channelId, streamMsgId, text2).catch((err) => logAndSwallow(TAG4, "adapter call", err));
+      } else if (text2) {
+        adapter.sendMessage(channelId, text2, { threadId: msg.threadId }).catch((err) => logAndSwallow(TAG4, "adapter call", err));
+      }
+      streamMsgId = void 0;
+    };
+    const response = await responsePromise;
+    clearTimeout(toolBatchTimer);
+    transport.onIntermediateResponse = void 0;
+    logDebug(TAG4, `Response (${response.length} chars): "${response.trim().slice(0, 120)}"`);
+    const cleanAnswer = transport.answerOnly;
+    const rawResponse = sessions.get(activeSessionId)?.fullMode ? response : cleanAnswer || response;
+    const { text: cleanedText, reactionEmoji, noReply, topics } = cleanResponse(rawResponse);
+    let userResponse = cleanedText;
+    for (const [key, val] of Object.entries(process.env)) {
+      if (key.startsWith("SECRET_") && val && userResponse.includes(val)) {
+        userResponse = userResponse.replaceAll(val, `[REDACTED:$${key}]`);
+        logWarn(TAG4, `Redacted leaked secret $${key} from response`);
+      }
+    }
+    if (!userResponse) {
+      if (noReply) {
+        logDebug(TAG4, "LLM returned [NO_REPLY], dropping silently");
+        return;
+      }
+      if (reactionEmoji) {
+        if (adapter.setReaction && msg.messageId) {
+          try {
+            await adapter.setReaction(channelId, msg.messageId, reactionEmoji);
+          } catch {
+            await adapter.sendMessage(channelId, reactionEmoji, { threadId: msg.threadId });
+          }
+        } else {
+          await adapter.sendMessage(channelId, reactionEmoji, { threadId: msg.threadId });
+        }
+        return;
+      }
+      if (transport.toolCallsSucceeded > 0) {
+        logDebug(TAG4, `Empty text but ${transport.toolCallsSucceeded} tool call(s) succeeded \u2014 suppressing fallback`);
+        if (adapter.setReaction && msg.messageId) await adapter.setReaction(channelId, msg.messageId, "").catch((err) => logAndSwallow(TAG4, "adapter call", err));
+      } else {
+        logWarn(TAG4, "Empty response from transport");
+        if (adapter.setReaction && msg.messageId) await adapter.setReaction(channelId, msg.messageId, "\u{1F937}");
+        await adapter.sendMessage(channelId, "\u{1F937} Model returned an empty response. Try again or /reset.", { threadId: msg.threadId });
+      }
+      return;
+    }
+    if (adapter.setReaction && msg.messageId) {
+      await adapter.setReaction(channelId, msg.messageId, "").catch((err) => logAndSwallow(TAG4, "adapter call", err));
+    }
+    const trimmed = userResponse.trim();
+    const isEmojiOnly = /^[\p{Emoji_Presentation}\p{Extended_Pictographic}]{1,2}$/u.test(trimmed);
+    if (isEmojiOnly) {
+      await tryReaction(adapter, channelId, msg.messageId, trimmed, msg.threadId);
+      return;
+    }
+    let lastSentMsgId;
+    const chunks = adapter.chunkResponse(userResponse);
+    logDebug(TAG4, `Sending ${chunks.length} chunk(s)`);
+    for (const chunk of chunks) {
+      const clean = chunk.replace(/\[TOPICS:\s*.+?\]/gi, "").replace(/\[REACT:.+?\]/gi, "").trim();
+      if (clean) {
+        await adapter.sendTyping?.(channelId, msg.threadId);
+        lastSentMsgId = await retrySend(() => adapter.sendMessage(channelId, clean, { threadId: msg.threadId }));
+      }
+    }
+    if (reactionEmoji) {
+      if (adapter.setReaction && msg.messageId) {
+        try {
+          await adapter.setReaction(channelId, msg.messageId, reactionEmoji);
+        } catch {
+          await adapter.sendMessage(channelId, reactionEmoji, { threadId: msg.threadId });
+        }
+      } else {
+        await adapter.sendMessage(channelId, reactionEmoji, { threadId: msg.threadId });
+      }
+    }
+    if (getEnv().activeMemory) {
+      const modelTopics = getEnv().primingModelTopics && topics ? topics : [];
+      const regexKw = extractKeywords(text);
+      const existing = sessions.get(activeSessionId)?.primingTerms ?? [];
+      sessions.getOrCreate(activeSessionId).primingTerms = [.../* @__PURE__ */ new Set([...modelTopics, ...regexKw, ...existing])].slice(0, PRIMING_MAX);
+    }
+    const isGuest = registry.byUserId.get(userId)?.role === "guest";
+    if (memory && !isGuest) {
+      memory.recordMessage({
+        role: "assistant",
+        content: cleanAnswer || response,
+        timestamp: Date.now(),
+        userId,
+        sessionId: activeSessionId,
+        platformMessageId: typeof lastSentMsgId === "number" ? lastSentMsgId : void 0
+      });
+    }
+    if (isVoice && ttsConfig && !sessions.get(activeSessionId)?.fullMode && adapter.sendVoice) {
+      try {
+        await adapter.sendTyping?.(channelId, msg.threadId);
+        const audio = await synthesizeSpeech(cleanAnswer || response, ttsConfig);
+        if (audio) {
+          await adapter.sendVoice(channelId, audio, { threadId: msg.threadId });
+          logInfo(TAG4, `\u{1F50A} Voice reply sent (${audio.length} bytes)`);
+        }
+      } catch (err) {
+        logWarn(TAG4, `TTS failed: ${err instanceof Error ? err.message : String(err)}`);
+      }
+    }
+    if (adapter.setReaction && msg.messageId) {
+      await adapter.setReaction(channelId, msg.messageId, "");
+    }
+    const ctxAfter = transport.contextPercent;
+    logInfo(TAG4, `\u2192 [${msg.platform}] Response delivered${ctxAfter >= 0 ? ` (ctx: ${ctxAfter}%)` : ""}`);
+    updateBridgeLockField("lastPromptAt", Date.now());
+    if (hasHooks("AfterMessage")) {
+      fire("AfterMessage", {
+        event: "AfterMessage",
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        sessionKey: activeSessionId,
+        platform: msg.platform,
+        userId,
+        chatId: String(chatId),
+        text,
+        response: userResponse,
+        model: "currentModel" in transport ? String(transport.currentModel) : "unknown",
+        success: true
+      }).catch((err) => logAndSwallow(TAG4, "adapter call", err));
+    }
+  } catch (err) {
+    if (err instanceof ModelNotFoundError) {
+      logWarn(TAG4, `Model not found for ${activeSessionId}: ${err.message}`);
+      await adapter.sendMessage(channelId, `\u274C ${err.message}
+Use /model to switch.`, { threadId: msg.threadId });
+    } else {
+      logError(TAG4, `Error for ${activeSessionId} \u2014 ${err instanceof Error ? err.message : JSON.stringify(err)}`);
+    }
+    if (adapter.setReaction && msg.messageId) {
+      await adapter.setReaction(channelId, msg.messageId, "").catch((err2) => logAndSwallow(TAG4, "adapter call", err2));
+    }
+    if (hasHooks("AfterMessage")) {
+      fire("AfterMessage", {
+        event: "AfterMessage",
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        sessionKey: activeSessionId,
+        platform: msg.platform,
+        userId,
+        chatId: String(chatId),
+        text,
+        success: false,
+        error: err instanceof Error ? err.message : String(err)
+      }).catch((err2) => logAndSwallow(TAG4, "adapter call", err2));
+    }
+    const errStr = String(err instanceof Error ? err.message : JSON.stringify(err));
+    const isContextOverflow = errStr.includes("ValidationException") || (errStr.includes("context window") || errStr.includes("token limit") || errStr.includes("maximum context"));
+    const isTimeout = errStr.includes("timed out") || errStr.includes("Prompt already in progress");
+    if (isContextOverflow) {
+      logWarn(TAG4, `Context overflow detected \u2014 auto-resetting session`);
+      await resetAndPrepare({ transport, sessionKey: activeSessionId, reason: `ctx-overflow: ${errStr.slice(0, 100)}`, sessions });
+      await adapter.sendMessage(channelId, "\u{1F504} Context window full \u2014 session reset. Send your message again.", { threadId: msg.threadId }).catch((err2) => logAndSwallow(TAG4, "adapter call", err2));
+    } else if (isTimeout) {
+      logWarn(TAG4, `Request timeout \u2014 not resetting session`);
+      await adapter.sendMessage(channelId, "\u274C Model timed out.", { threadId: msg.threadId }).catch((err2) => logAndSwallow(TAG4, "adapter call", err2));
+    } else {
+      const reason = errStr.includes("rate") || errStr.includes("429") ? "Rate limited." : errStr.includes("auth") || errStr.includes("401") || errStr.includes("403") ? "Authentication failed." : errStr.includes("connect") || errStr.includes("ECONNREFUSED") ? "Connection lost." : errStr.includes("exhausted") || errStr.includes("no candidates") ? "All models exhausted." : "Something went wrong.";
+      await adapter.sendMessage(channelId, `\u274C ${reason}`, { threadId: msg.threadId }).catch((err2) => logAndSwallow(TAG4, "adapter call", err2));
+    }
+  } finally {
+    clearInterval(typingInterval);
+    clearTimeout(typingTtlTimer);
+    if (toolElapsedTimer) clearInterval(toolElapsedTimer);
+    transport.onToolCallStart = void 0;
+    transport.onSegmentBreak = void 0;
+    busyEntry.busy = false;
+    idleSave.reset(activeSessionId, chatId);
+    const entry = sessions.get(activeSessionId);
+    if (entry?.queue.length) {
+      const next = entry.queue.shift();
+      logInfo(TAG4, `Draining queued message for ${activeSessionId} (${entry.queue.length} remaining)`);
+      handleInboundMessage(next.msg, next.adapter, deps).catch((e) => logError(TAG4, "Queue drain error", e));
+    }
+  }
+}
+async function startSession(transport, memory, userId, sessionKey, greeting, sendResponse) {
+  const prompt = buildSessionStartPrompt(greeting, memory, userId, sessionKey);
+  logInfo(TAG4, `Session start for ${sessionKey} \u2014 prompt ${prompt.length} chars`);
+  const response = await transport.sendPrompt(sessionKey, prompt, void 0, userId);
+  if (response?.trim() && response.trim() !== "[NO_REPLY]" && response.trim() !== "(no response)") {
+    await sendResponse(response);
+  }
+}
+
+// src/components/commands/registry.ts
+init_log_and_swallow();
+var TAG5 = "cmd_registry";
+var exactCommands = {};
+var prefixCommands = [];
+var KNOWN_COMMANDS = /* @__PURE__ */ new Set();
+var NON_MASTER_COMMANDS = /* @__PURE__ */ new Set(["/new", "/reset", "/stop", "/ctrlc", "/status", "/help", "/whoami"]);
+function registerExact(name, handler) {
+  exactCommands[name] = handler;
+  KNOWN_COMMANDS.add(name);
+}
+function registerPrefix(prefix, handler) {
+  prefixCommands.push({ prefix, handler });
+  KNOWN_COMMANDS.add(prefix.split(" ")[0]);
+}
+function registerCommand(name, handler) {
+  registerExact(name, handler);
+}
+async function handleCommand(text, ctx) {
+  const isMaster = !ctx.userId || ctx.userId === "master" || (await import("./user-registry-GTAJIW6E.js")).loadUsers().byUserId.get(ctx.userId)?.role === "master";
+  if (!isMaster) {
+    const cmd = text.split(/\s/)[0];
+    if (cmd.startsWith("/") && !NON_MASTER_COMMANDS.has(cmd)) {
+      await ctx.reply("\u26D4 Owner-only command.");
+      return true;
+    }
+  }
+  const exact = exactCommands[text];
+  if (exact) return exact(text, ctx);
+  for (const { prefix, handler } of prefixCommands) {
+    if (text.startsWith(prefix)) return handler(text, ctx);
+  }
+  const firstWord = text.split(/\s/)[0];
+  if (text !== firstWord) {
+    const byFirstWord = exactCommands[firstWord];
+    if (byFirstWord) return byFirstWord(text, ctx);
+  }
+  if (text.startsWith("/") && /^\/\w+/.test(text) && !text.startsWith("//")) {
+    const cmd = text.split(/\s/)[0];
+    if (!KNOWN_COMMANDS.has(cmd)) {
+      await ctx.reply(`\u2753 Unknown command: ${cmd}
+Type /help for available commands.`);
+      return true;
+    }
+  }
+  return false;
+}
+async function triggerNewSession(ctx, reason = "new-session") {
+  const { hasHooks: hasHooks2, fire: fireHook } = await import("./hook-system-POI5VRIX.js");
+  if (hasHooks2("SessionEnd")) {
+    await fireHook("SessionEnd", { event: "SessionEnd", timestamp: (/* @__PURE__ */ new Date()).toISOString(), sessionKey: ctx.sessionKey, platform: ctx.platform, userId: ctx.userId, reason }).catch((err) => logAndSwallow(TAG5, "fireHook session", err));
+  }
+  await ctx.idleSave.save(ctx.sessionKey, ctx.chatId);
+  await resetAndPrepare({
+    transport: ctx.transport,
+    sessionKey: ctx.sessionKey,
+    reason,
+    sessions: ctx.sessions,
+    conversationBuffer: ctx.conversationBuffer,
+    bufKey: ctx.bufKey
+  });
+  if (ctx.memoryConfig.memoryEnabled) ctx.updateCtxStart(ctx.memoryConfig.memoryDir, ctx.userId);
+  if (hasHooks2("SessionStart")) {
+    await fireHook("SessionStart", { event: "SessionStart", timestamp: (/* @__PURE__ */ new Date()).toISOString(), sessionKey: ctx.sessionKey, platform: ctx.platform, userId: ctx.userId, reason }).catch((err) => logAndSwallow(TAG5, "fireHook session", err));
+  }
+}
+async function triggerResetSession(ctx) {
+  const { hasHooks: hasHooks2, fire: fireHook } = await import("./hook-system-POI5VRIX.js");
+  if (hasHooks2("SessionEnd")) {
+    await fireHook("SessionEnd", { event: "SessionEnd", timestamp: (/* @__PURE__ */ new Date()).toISOString(), sessionKey: ctx.sessionKey, platform: ctx.platform, userId: ctx.userId, reason: "reset-transport" }).catch((err) => logAndSwallow(TAG5, "fireHook session", err));
+  }
+  await ctx.idleSave.save(ctx.sessionKey, ctx.chatId);
+  const { clearTransportCache } = await import("./transport-config-ANPS2RYT.js");
+  clearTransportCache();
+  if (ctx.rebuildTransport) await ctx.rebuildTransport();
+  await resetAndPrepare({
+    transport: ctx.transport,
+    sessionKey: ctx.sessionKey,
+    reason: "reset-transport",
+    sessions: ctx.sessions,
+    conversationBuffer: ctx.conversationBuffer,
+    bufKey: ctx.bufKey
+  });
+  if (ctx.memoryConfig.memoryEnabled) ctx.updateCtxStart(ctx.memoryConfig.memoryDir, ctx.userId);
+  if (hasHooks2("SessionStart")) {
+    await fireHook("SessionStart", { event: "SessionStart", timestamp: (/* @__PURE__ */ new Date()).toISOString(), sessionKey: ctx.sessionKey, platform: ctx.platform, userId: ctx.userId, reason: "reset-transport" }).catch((err) => logAndSwallow(TAG5, "fireHook session", err));
+  }
+}
+var _wakeInhibitPid = null;
+function killWakeInhibit() {
+  if (_wakeInhibitPid) {
+    try {
+      process.kill(_wakeInhibitPid);
+    } catch (err) {
+      logAndSwallow("command_handlers", "op", err);
+    }
+    logInfo("wakeup", `Killed wake inhibitor pid=${_wakeInhibitPid}`);
+    _wakeInhibitPid = null;
+  }
+}
+function setWakeInhibitPid(pid) {
+  _wakeInhibitPid = pid;
+}
+
+// src/components/commands/handlers-transport.ts
+init_logger();
+init_log_and_swallow();
+var TAG6 = "cmd";
+async function handleNewReset(text, ctx) {
+  const isResetDefault = text.trim().toLowerCase() === "/reset default";
+  if (isResetDefault) {
+    const { resetToDefaults } = await import("./transport-config-ANPS2RYT.js");
+    resetToDefaults();
+  } else {
+    try {
+      await triggerResetSession(ctx);
+    } catch (err) {
+      await ctx.reply(`\u26A0\uFE0F Transport rebuild failed: ${err instanceof Error ? err.message : String(err)}`);
+      return true;
+    }
+  }
+  ctx.sessionManager.endSession(ctx.userId, ctx.platform);
+  const activeId = ctx.sessionManager.getActiveSessionId(ctx.userId, ctx.platform);
+  await ctx.transport.resetSession(activeId);
+  const label = isResetDefault ? "\u{1F504} Reset to defaults." : "\u{1F504} Transport reloaded.";
+  await ctx.reply(label);
+  logInfo(TAG6, `Reset session \u2192 ${activeId} (${ctx.platform})`);
+  return true;
+}
+async function handleCompact(_text, ctx) {
+  try {
+    const transport = ctx.transport;
+    if (transport.contextOrchestrator) {
+      const budget = transport.config?.maxContext ?? 2e5;
+      const success = await transport.contextOrchestrator.forceCompact(ctx.sessionKey, budget);
+      await ctx.reply(success ? "\u{1F4E6} Compaction complete." : "\u{1F4E6} Nothing to compact.");
+    } else {
+      await ctx.reply("\u{1F4E6} Context engine not active for this transport.");
+    }
+  } catch (err) {
+    logError(TAG6, "Manual compaction failed", err);
+    await ctx.reply("\u274C Compaction failed.");
+  }
+  return true;
+}
+async function handleEmergencyAlias(_text, ctx) {
+  return handleModels("/model emergency", ctx);
+}
+async function handleModels(text, ctx) {
+  const { loadTransport, resolveAgent, getModelsForProvider, writeTransportConfig } = await import("./transport-config-ANPS2RYT.js");
+  const tc = loadTransport();
+  const prof = tc ? resolveAgent("professor", tc) : null;
+  const currentModel = ("currentModel" in ctx.transport ? ctx.transport.currentModel : void 0) ?? prof?.model ?? "unknown";
+  const arg = text.replace(/^\/(models?)\s*/i, "").trim().toLowerCase();
+  if (arg === "emergency" || arg === "hailmary") {
+    if (!ctx.hailMary) {
+      await ctx.reply("\u274C hailMary not configured in transport.json");
+      return true;
+    }
+    const t = ctx.transport;
+    if (!t.setEmergencyMode) {
+      await ctx.reply("\u274C Transport does not support emergency mode");
+      return true;
+    }
+    if (tc) {
+      const hmProvider = tc.hailMary ? tc.providers[tc.hailMary.provider] : void 0;
+      if (hmProvider) {
+        const { validateProviderReady, formatValidationError } = await import("./transport-config-ANPS2RYT.js");
+        const { getEnv: getEnv2 } = await import("./env-schema-DGD6QWPA.js");
+        const result = validateProviderReady(tc.hailMary.provider, hmProvider, getEnv2());
+        if (!result.ok) {
+          await ctx.reply(formatValidationError(tc.hailMary.provider, result));
+          return true;
+        }
+      }
+    }
+    t.setEmergencyMode({ ...ctx.hailMary, maxContext: 1e6 });
+    await ctx.reply(`\u{1F6A8} EMERGENCY MODE: using ${ctx.hailMary.model} (paid). Clears on /model restore, /reset, or wake-up.`);
+    return true;
+  }
+  if (arg === "restore") {
+    const { restorePrevious } = await import("./transport-config-ANPS2RYT.js");
+    const result = restorePrevious();
+    if (!result.ok) {
+      await ctx.reply(`\u274C ${result.error}`);
+      return true;
+    }
+    const t = ctx.transport;
+    t.setEmergencyMode?.(null);
+    await ctx.reply("\u{1F504} Restored previous config.");
+    return true;
+  }
+  if (arg === "default") {
+    const { resetToDefaults } = await import("./transport-config-ANPS2RYT.js");
+    if (!resetToDefaults()) {
+      await ctx.reply("\u274C Factory config not found \u2014 run abtars install to restore.");
+      return true;
+    }
+    await ctx.reply("\u{1F504} Factory config restored.");
+    return true;
+  }
+  if (arg === "health reset" || arg === "primary") {
+    const t = ctx.transport;
+    const wasEmergency = t.isEmergencyMode;
+    t.setEmergencyMode?.(null);
+    if (t.policy?.registry) {
+      t.policy.registry.resetAll();
+      await ctx.reply(wasEmergency ? "\u{1F50C} Emergency mode cleared + model health reset \u2014 free models active." : "\u{1F50C} Model health reset \u2014 all models available.");
+    } else {
+      await ctx.reply("\u{1F50C} No fallback policy configured.");
+    }
+    return true;
+  }
+  if (arg === "doctor") {
+    if (!prof) {
+      await ctx.reply("\u274C No transport configured.");
+      return true;
+    }
+    const endpoint = prof.provider.endpoint ?? "http://localhost:11434/v1";
+    const apiKey = prof.provider.apiKeyEnv ? (await import("./env-schema-DGD6QWPA.js")).getEnv().getApiKey(prof.provider.apiKeyEnv) : void 0;
+    const models = /* @__PURE__ */ new Set();
+    for (const [, agent] of Object.entries(tc.agents)) {
+      if (agent.provider === prof.providerName) models.add(agent.model);
+      for (const fb of agent.fallbacks ?? []) {
+        if (fb.provider === prof.providerName) models.add(fb.model);
+      }
+    }
+    if (tc.hailMary?.provider === prof.providerName) models.add(tc.hailMary.model);
+    await ctx.reply(`\u{1FA7A} Checking ${models.size} models on ${prof.providerName}...`);
+    const results = [];
+    const { loadModels } = await import("./transport-config-ANPS2RYT.js");
+    const catalog = loadModels();
+    for (const model of models) {
+      try {
+        const res = await fetch(`${endpoint}/chat/completions`, {
+          method: "POST",
+          headers: { "Content-Type": "application/json", ...apiKey ? { Authorization: `Bearer ${apiKey}` } : {} },
+          body: JSON.stringify({ model, messages: [{ role: "user", content: "hi" }], max_tokens: 1 }),
+          signal: AbortSignal.timeout(1e4)
+        });
+        if (res.ok) {
+          results.push(`\u2705 ${model} \u2014 alive`);
+          if (catalog[model]) catalog[model].status = "alive";
+        } else {
+          const body = await res.text().catch((err) => {
+            logAndSwallow(TAG6, "read model probe error body", err);
+            return "";
+          });
+          const short = body.slice(0, 80).replace(/\n/g, " ");
+          const status = res.status === 404 ? "dead" : res.status === 403 ? "subscription" : res.status === 429 ? "rate_limited" : "error";
+          results.push(`\u274C ${model} \u2014 ${status} (${res.status}: ${short})`);
+          if (catalog[model]) {
+            catalog[model].status = status;
+            catalog[model].error = `${res.status}: ${short}`;
+          }
+        }
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        results.push(`\u26A0\uFE0F ${model} \u2014 timeout/error (${msg.slice(0, 60)})`);
+        if (catalog[model]) {
+          catalog[model].status = "dead";
+          catalog[model].error = msg.slice(0, 80);
+        }
+      }
+      if (catalog[model]) catalog[model].lastChecked = (/* @__PURE__ */ new Date()).toISOString();
+    }
+    const { writeFileSync: writeFileSync2 } = await import("node:fs");
+    const { join: join5 } = await import("node:path");
+    const { configDir } = await import("./transport-config-ANPS2RYT.js");
+    writeFileSync2(join5(configDir(), "models.json"), JSON.stringify(catalog, null, 2) + "\n");
+    await ctx.reply(`\u{1FA7A} Model Health:
+${results.join("\n")}`);
+    return true;
+  }
+  if (arg.startsWith("quick ") || arg.startsWith("switch ")) {
+    const newModel = arg.split(" ").slice(1).join(" ").trim();
+    if (!newModel) {
+      await ctx.reply("Usage: /models quick <model>");
+      return true;
+    }
+    if (!tc || !prof) {
+      await ctx.reply("\u274C transport.json not loaded");
+      return true;
+    }
+    const models = getModelsForProvider(prof.providerName);
+    const match = models.find((m) => m.id === newModel);
+    if (!match) {
+      await ctx.reply(`\u274C ${newModel} not available on ${prof.providerName}. Use /models change to switch provider.`);
+      return true;
+    }
+    {
+      const { validateProviderReady, formatValidationError } = await import("./transport-config-ANPS2RYT.js");
+      const { getEnv: getEnv2 } = await import("./env-schema-DGD6QWPA.js");
+      const result = validateProviderReady(prof.providerName, prof.provider, getEnv2());
+      if (!result.ok) {
+        await ctx.reply(formatValidationError(prof.providerName, result));
+        return true;
+      }
+    }
+    tc.agents["professor"].model = newModel;
+    const { cleanDemotedModels } = await import("./transport-config-ANPS2RYT.js");
+    cleanDemotedModels(tc, newModel);
+    writeTransportConfig(tc, `professor model \u2192 ${newModel}`);
+    if ("setModel" in ctx.transport) {
+      await ctx.transport.setModel(newModel);
+    }
+    await ctx.reply(`\u2705 Switched to ${newModel}`);
+    return true;
+  }
+  if (arg === "list" || arg.startsWith("list ")) {
+    const providerArg = arg.slice(5).trim();
+    const { getAvailableProviders, getModelsForProvider: getModels } = await import("./transport-config-ANPS2RYT.js");
+    if (!tc) {
+      await ctx.reply("\u274C transport.json not loaded");
+      return true;
+    }
+    if (!providerArg) {
+      const providers = getAvailableProviders(tc);
+      const lines2 = ["\u{1F50C} Providers:"];
+      for (const p of providers) {
+        const count = getModels(p.name).length;
+        lines2.push(`  \u2022 ${p.name} (${p.config.transport})${count > 0 ? ` \u2014 ${count} models` : ""}`);
+      }
+      lines2.push("\nUse /model list <provider> to see models.");
+      await ctx.reply(lines2.join("\n"));
+    } else {
+      const models = getModels(providerArg);
+      if (models.length === 0) {
+        await ctx.reply(`\u274C No models found for provider "${providerArg}"`);
+        return true;
+      }
+      const lines2 = [`\u{1F4CB} Models on ${providerArg}:`];
+      for (const m of models) {
+        const current = m.id === currentModel ? " \u2705" : "";
+        lines2.push(`  \u2022 ${m.id}${current}`);
+      }
+      lines2.push(`
+Use /model quick <name> to switch.`);
+      await ctx.reply(lines2.join("\n"));
+    }
+    return true;
+  }
+  if (arg === "change") {
+    if (ctx.platform !== "telegram") {
+      await ctx.reply("\u{1F916} Use /model list to discover, /model quick <model> to switch.");
+      return true;
+    }
+    const AGENT_LABELS = [
+      { key: "professor", label: "Professor" },
+      { key: "dreamy", label: "Dreamy (sleep)" },
+      { key: "browsie", label: "Browsie (browse)" },
+      { key: "coding", label: "Cody (coding)" }
+    ];
+    const buttons = AGENT_LABELS.map((a) => [{ text: a.label, callback_data: `mslot:${a.key}` }]);
+    buttons.push([{ text: "\u2190 Cancel", callback_data: "mb:" }]);
+    await ctx.reply("\u{1F916} Which agent to change?", { reply_markup: { inline_keyboard: buttons } });
+    return true;
+  }
+  if (arg.startsWith("provider ")) {
+    const providerName = arg.slice(9).trim();
+    if (!tc || !prof) {
+      await ctx.reply("\u274C transport.json not loaded");
+      return true;
+    }
+    const provider2 = tc.providers[providerName];
+    if (!provider2) {
+      await ctx.reply(`\u274C Provider "${providerName}" not found. Available: ${Object.keys(tc.providers).join(", ")}`);
+      return true;
+    }
+    const { validateProviderReady, formatValidationError, loadProviderDefaults } = await import("./transport-config-ANPS2RYT.js");
+    const { getEnv: getEnv2 } = await import("./env-schema-DGD6QWPA.js");
+    const validation = validateProviderReady(providerName, provider2, getEnv2());
+    if (!validation.ok) {
+      await ctx.reply(formatValidationError(providerName, validation));
+      return true;
+    }
+    const defaults = loadProviderDefaults(providerName);
+    if (defaults?.professor) {
+      tc.agents["professor"] = { model: defaults.professor.model, provider: providerName, fallbacks: defaults.professor.fallbacks?.map((m) => ({ model: m, provider: providerName })) };
+      for (const role of ["dreamy", "browsie", "coding"]) {
+        tc.agents[role] = { model: defaults[role]?.model ?? defaults.professor.model, provider: providerName };
+      }
+    } else {
+      for (const role of Object.keys(tc.agents)) {
+        tc.agents[role] = { ...tc.agents[role], provider: providerName };
+      }
+    }
+    writeTransportConfig(tc, `global provider \u2192 ${providerName}`);
+    await ctx.reply(`\u2705 All agents \u2192 ${providerName}. Use /reset to apply.`);
+    return true;
+  }
+  const transportStatus = ctx.transport.isReady ? "\u2713 Connected" : "\u274C Disconnected";
+  const ctxPct = ctx.transport.contextPercent >= 0 ? `${ctx.transport.contextPercent}%` : "n/a";
+  const mode = prof?.provider.transport?.toUpperCase() ?? "ACP";
+  const provider = prof?.providerName ?? "unknown";
+  const isEmergency = ctx.transport.isEmergencyMode === true;
+  const lines = [
+    `\u{1F50C} Transport: ${mode} (${provider}) \u2014 ${transportStatus}`,
+    isEmergency ? `\u{1F6A8} EMERGENCY MODE: ${currentModel} (paid)` : `\u{1F916} Model: ${currentModel}`,
+    `\u{1F4CA} Context: ${ctxPct}`,
+    "",
+    "\u{1F4CB} Agents:"
+  ];
+  const agents = ["professor", "dreamy", "browsie", "coding"];
+  const names = { professor: "Professor", dreamy: "Dreamy", browsie: "Browsie", coding: "Cody" };
+  for (const a of agents) {
+    const r = tc ? resolveAgent(a, tc) : null;
+    let line = `  ${names[a]}: ${r?.model ?? "unknown"} (${r?.providerName ?? "?"}, ${r?.provider.transport ?? "?"})`;
+    if (a === "professor" && r?.fallbacks.length) {
+      line += "\n" + r.fallbacks.map((f, i) => `    \u21B3 fb${i + 1}: ${f.model} (${f.provider})`).join("\n");
+    }
+    lines.push(line);
+  }
+  lines.push("  Cron: inherits Professor");
+  if (prof?.provider.fallbackChain?.length) {
+    lines.push(`
+\u{1F6DF} Fallback chain: ${prof.provider.fallbackChain.join(" \u2192 ")}`);
+  }
+  if (ctx.hailMary) {
+    lines.push(`\u{1F6A8} hailMary: ${ctx.hailMary.model} `);
+  }
+  lines.push("\nUse /models change to switch.");
+  await ctx.reply(lines.join("\n"));
+  return true;
+}
+
+// src/components/commands/exec-async.ts
+import { execFile } from "node:child_process";
+function execAsync(cmd, args, timeoutMs) {
+  return new Promise((resolve) => {
+    const child = execFile(cmd, args, { timeout: timeoutMs, encoding: "utf-8" }, (err, stdout) => {
+      resolve(err ? null : stdout.trim());
+    });
+    child.stderr?.resume();
+  });
+}
+
+// src/components/commands/handlers-system.ts
+init_logger();
+init_log_and_swallow();
+import { readFileSync, readdirSync } from "node:fs";
+import { join as join2 } from "node:path";
+import { homedir } from "node:os";
+init_paths();
+var TAG7 = "cmd";
+async function handleDoctor(_text, ctx) {
+  const arg = _text.replace(/^\/doctor\s*/i, "").trim().toLowerCase();
+  if (arg === "fix" || arg === "fix-full") {
+    const flag = arg === "fix-full" ? "--fix-full" : "--fix";
+    try {
+      const raw = await execAsync("bash", [join2(abtarsHome(), "scripts", "doctor.sh"), flag], 3e4);
+      await ctx.reply(`\u{1FA7A} doctor.sh ${flag}:
+${raw || "(no output)"}`);
+    } catch (err) {
+      await ctx.reply(`\u274C doctor.sh failed: ${err instanceof Error ? err.message : String(err)}`);
+    }
+    return true;
+  }
+  const { getDoctorReport, renderDoctorText } = await import("./doctor-R54GZPKL.js");
+  const force = arg === "force";
+  const svcStates = ctx.registry?.getStates() ?? {};
+  const report = await getDoctorReport({
+    memory: ctx.memory,
+    transport: ctx.transport,
+    telegramRunning: svcStates.telegram?.running ?? false,
+    discordRunning: svcStates.discord?.running ?? false,
+    phaseHealth: ctx.phaseHealth
+  }, { force });
+  await ctx.reply(renderDoctorText(report));
+  return true;
+}
+async function handleStatus(_text, ctx) {
+  if (ctx.phaseHealth && ctx.registry) {
+    const { getSystemStatus, renderStatusText } = await import("./system-status-2CR5OUDY.js");
+    const status = await getSystemStatus({
+      phaseHealth: ctx.phaseHealth,
+      registry: ctx.registry,
+      transport: ctx.transport,
+      startedAt: ctx.startedAt,
+      bridgeLockPath: ctx.bridgeLockPath ?? "",
+      heartbeat: { intervalMs: Math.max(60, parseInt(process.env["HEARTBEAT_INTERVAL_SEC"] ?? "60", 10)) * 1e3 }
+    });
+    let text = renderStatusText(status);
+    if (_text.trim().toLowerCase() === "full") {
+      const { envDump } = await import("./env-schema-DGD6QWPA.js");
+      const dump = envDump();
+      const envLines = Object.entries(dump).slice(0, 30).map(([k, v]) => `  ${k}: ${v}`);
+      text += "\n\n\u{1F4CB} Config (top 30):\n" + envLines.join("\n");
+    }
+    await ctx.reply(text);
+  } else {
+    const lines = await buildStatusLines(ctx);
+    await ctx.reply(lines.join("\n"));
+  }
+  return true;
+}
+async function handleWait(text, ctx) {
+  const body = text.replace(/^\/(wait|steer)\s*/i, "").trim();
+  if (!body) {
+    await ctx.reply("Nothing running. Send a message to start.");
+    return true;
+  }
+  return false;
+}
+async function handleStop(_text, ctx) {
+  await ctx.transport.sendInterrupt();
+  ctx.sessions.getOrCreate(ctx.sessionKey).busy = false;
+  await ctx.reply("\u{1F6D1} Ctrl+C sent.");
+  logInfo(TAG7, "Ctrl+C interrupt sent");
+  return true;
+}
+async function handleRestart(_text, ctx) {
+  await ctx.reply("\u267B\uFE0F Restarting bridge...");
+  setTimeout(() => ctx.requestShutdown?.(0), 500);
+  return true;
+}
+async function handleHeartbeat(_text, ctx) {
+  const cronInfo = ctx.memory?.getCronInfo();
+  if (!cronInfo) {
+    await ctx.reply("\u{1F493} Heartbeat not available.");
+    return true;
+  }
+  const mins = Math.round(cronInfo.intervalMs / 6e4);
+  const lines = [
+    `\u{1F493} Heartbeat: ${cronInfo.heartbeatRunning ? "running" : "stopped"} (${mins}min interval)`,
+    ""
+  ];
+  if (cronInfo.taskStatuses.size > 0) {
+    lines.push("Tasks (last tick):");
+    for (const [name, status] of cronInfo.taskStatuses) {
+      lines.push(`  ${status} ${name}`);
+    }
+  }
+  try {
+    const lock = JSON.parse(readFileSync(join2(abtarsHome(), "bridge.lock"), "utf-8"));
+    if (lock.lastHeartbeat > 0) {
+      const agoMin = Math.round((Date.now() - lock.lastHeartbeat) / 6e4);
+      lines.push("", `\u{1FAC0} Last tick: ${agoMin}min ago`);
+    }
+  } catch (err) {
+    logAndSwallow("command_handlers", "op", err);
+  }
+  await ctx.reply(lines.join("\n"));
+  return true;
+}
+async function handleHealing(text, ctx) {
+  if (!ctx.selfHealerTask) {
+    await ctx.reply("\u{1FA7A} Self-healer not available.");
+    return true;
+  }
+  const arg = text.replace(/^\/healing\s*/, "").trim().toLowerCase();
+  if (arg === "on") {
+    ctx.selfHealerTask.enabled = true;
+  } else if (arg === "off") {
+    ctx.selfHealerTask.enabled = false;
+  } else if (arg === "reset") {
+    ctx.selfHealerTask.resetCircuitBreaker?.();
+    await ctx.reply("\u{1FA7A} Circuit breaker reset \u2014 all paused rules re-enabled.");
+    return true;
+  }
+  const status = ctx.selfHealerTask.enabled ? "ON" : "OFF";
+  const paused = ctx.selfHealerTask.pausedRules?.() ?? 0;
+  const pausedText = paused > 0 ? ` (${paused} rule${paused > 1 ? "s" : ""} paused)` : "";
+  await ctx.reply(`\u{1FA7A} Self-healing: ${status}${pausedText}`);
+  if (arg === "on" || arg === "off") logInfo(TAG7, `Self-healer ${status} by user`);
+  return true;
+}
+async function handleFull(_text, ctx) {
+  if (ctx.platform !== "telegram") {
+    await ctx.reply("\u{1F4FA} Full mode is only available on Telegram.");
+    return true;
+  }
+  ctx.sessions.getOrCreate(ctx.sessionKey).fullMode = true;
+  await ctx.reply("\u{1F4FA} Full mode \u2014 sending raw output, TTS disabled.");
+  return true;
+}
+async function handleShort(_text, ctx) {
+  if (ctx.platform !== "telegram") {
+    await ctx.reply("\u2702\uFE0F Short mode is only available on Telegram.");
+    return true;
+  }
+  ctx.sessions.getOrCreate(ctx.sessionKey).fullMode = false;
+  await ctx.reply("\u2702\uFE0F Short mode \u2014 clean responses, TTS enabled.");
+  return true;
+}
+async function buildStatusLines(ctx) {
+  let version = "?";
+  let buildInfo = "";
+  try {
+    const pkgPath = join2(import.meta.dirname, "..", "..", "..", "package.json");
+    version = JSON.parse(readFileSync(pkgPath, "utf-8")).version;
+  } catch (err) {
+    logAndSwallow("command_handlers", "op", err);
+  }
+  try {
+    const biPath = join2(import.meta.dirname, "..", "..", "build-info.json");
+    const bi = JSON.parse(readFileSync(biPath, "utf-8"));
+    buildInfo = ` (${bi.hash} ${bi.date.slice(0, 10)})`;
+  } catch (err) {
+    logAndSwallow("command_handlers", "op", err);
+  }
+  let model = "unknown";
+  if ("currentModel" in ctx.transport) {
+    model = ctx.transport.currentModel;
+  } else {
+    const { loadTransport, resolveAgent } = await import("./transport-config-ANPS2RYT.js");
+    const tc2 = loadTransport();
+    const prof2 = tc2 ? resolveAgent("professor", tc2) : null;
+    model = prof2?.model ?? "unknown";
+  }
+  const transportStatus = ctx.transport.isReady ? "\u2713 Connected" : "\u274C Disconnected";
+  const uptime = formatUptime(Date.now() - ctx.startedAt);
+  const ctxPct = ctx.transport.contextPercent >= 0 ? `${ctx.transport.contextPercent}%` : "n/a";
+  const cronInfo = ctx.memory?.getCronInfo();
+  const { loadTransport: lt, resolveAgent: ra } = await import("./transport-config-ANPS2RYT.js");
+  const tc = lt();
+  const prof = tc ? ra("professor", tc) : null;
+  const provider = prof?.providerName ?? "unknown";
+  const mode = prof?.provider.transport?.toUpperCase() ?? "ACP";
+  const transportLine = `\u{1F50C} Transport: ${mode} (${provider}) \u2014 ${transportStatus}`;
+  const fallbackModels = prof?.fallbacks.map((f) => `${f.model} (${f.provider})`) ?? [];
+  const lines = [
+    `Abtars v${version}${buildInfo}`,
+    transportLine,
+    `\u{1F916} Model: ${model}`,
+    ...fallbackModels.length > 0 ? [`   Fallbacks: ${fallbackModels.join(", ")}`] : [],
+    `\u{1F4CA} Context window: ${ctxPct}`,
+    `\u23F1\uFE0F Uptime: ${uptime}`
+  ];
+  if (cronInfo) {
+    const mins = Math.round(cronInfo.intervalMs / 6e4);
+    lines.push(
+      `\u{1F493} Heartbeat: ${cronInfo.heartbeatRunning ? "running" : "stopped"} (${mins}min)`
+    );
+    if (ctx.loadedCapabilities?.length) {
+      lines.push(`\u{1F50C} Capabilities: ${ctx.loadedCapabilities.join(", ")}`);
+    }
+    lines.push(`\u{1F634} Last sleep: ${cronInfo.lastSleepAudit ?? "(never)"}`);
+    const sp = ctx.sleepProgress?.();
+    if (sp) {
+      lines.push(`\u{1F634} Sleep: ${sp.percent}% (${sp.step})`);
+    }
+    try {
+      const lock = JSON.parse(readFileSync(join2(abtarsHome(), "bridge.lock"), "utf-8"));
+      if (lock.lastHeartbeat > 0) lines.push(`\u{1FAC0} Last tick: ${Math.round((Date.now() - lock.lastHeartbeat) / 6e4)}min ago`);
+    } catch (err) {
+      logAndSwallow("command_handlers", "op", err);
+    }
+    try {
+      const ce = readEntries();
+      const r = ce.filter((e) => e.schedule && !e.paused).length;
+      const p = ce.filter((e) => !e.fired && !e.schedule).length;
+      const pa = ce.filter((e) => e.paused).length;
+      lines.push(`\u23F0 Tasks: ${r} recurring, ${p} pending${pa ? `, ${pa} paused` : ""}`);
+    } catch (err) {
+      logAndSwallow("command_handlers", "op", err);
+    }
+    try {
+      const bd = join2(homedir(), ".backup-abtars");
+      const bk = readdirSync(bd).filter((f) => f.startsWith("abtars-")).sort();
+      if (bk.length > 0) lines.push(`\u{1F4BE} Last backup: ${bk[bk.length - 1]}`);
+    } catch (err) {
+      logAndSwallow("command_handlers", "op", err);
+    }
+  }
+  lines.push("");
+  lines.push("Use /mcp for MCP server status.");
+  return lines;
+}
+function formatUptime(ms) {
+  const h = Math.floor(ms / 36e5);
+  const m = Math.floor(ms % 36e5 / 6e4);
+  return h > 0 ? `${h}h ${m}m` : `${m}m`;
+}
+async function handleUsage(_text, ctx) {
+  const { readUsage, resetUsage } = await import("./usage-tracker-S4Z2G2K5.js");
+  const { loadModels } = await import("./transport-config-ANPS2RYT.js");
+  const arg = _text.replace("/usage", "").trim();
+  if (arg === "reset") {
+    resetUsage();
+    await ctx.reply("\u2713 Usage stats reset.");
+    return true;
+  }
+  const models = loadModels();
+  const costTable = /* @__PURE__ */ new Map();
+  for (const [id, entry] of Object.entries(models)) {
+    costTable.set(id, entry.cost);
+  }
+  const now = Date.now();
+  const startOfToday = (/* @__PURE__ */ new Date()).setHours(0, 0, 0, 0);
+  const startOfYesterday = startOfToday - 864e5;
+  const startOfDayBefore = startOfYesterday - 864e5;
+  const today = readUsage(startOfToday, costTable);
+  const yesterday = readUsage(startOfYesterday, costTable);
+  const dayBefore = readUsage(startOfDayBefore, costTable);
+  const week = readUsage(now - 7 * 864e5, costTable);
+  const month = readUsage(now - 30 * 864e5, costTable);
+  const yIn = yesterday.inputTokens - today.inputTokens;
+  const yOut = yesterday.outputTokens - today.outputTokens;
+  const yCost = yesterday.cost - today.cost;
+  const dbIn = dayBefore.inputTokens - yesterday.inputTokens;
+  const dbOut = dayBefore.outputTokens - yesterday.outputTokens;
+  const dbCost = dayBefore.cost - yesterday.cost;
+  const fmt = (n) => n >= 1e6 ? `${(n / 1e6).toFixed(1)}M` : n >= 1e3 ? `${(n / 1e3).toFixed(1)}k` : String(n);
+  const fmtCost = (c) => c < 0.01 ? `$${c.toFixed(4)}` : `$${c.toFixed(2)}`;
+  let msg = `\u{1F4CA} Token usage
+
+`;
+  msg += `Today:      ${fmt(today.inputTokens)} / ${fmt(today.outputTokens)} \u2014 ${fmtCost(today.cost)}
+`;
+  msg += `Yesterday:  ${fmt(yIn)} / ${fmt(yOut)} \u2014 ${fmtCost(yCost)}
+`;
+  msg += `Day before: ${fmt(dbIn)} / ${fmt(dbOut)} \u2014 ${fmtCost(dbCost)}
+`;
+  msg += `Last 7d:    ${fmt(week.inputTokens)} / ${fmt(week.outputTokens)} \u2014 ${fmtCost(week.cost)}
+`;
+  msg += `Last 30d:   ${fmt(month.inputTokens)} / ${fmt(month.outputTokens)} \u2014 ${fmtCost(month.cost)}
+`;
+  if (arg === "detail") {
+    msg += `
+\u{1F4CB} Today by model:
+`;
+    for (const [model, stats] of today.byModel) {
+      msg += `  ${model}: ${fmt(stats.in)}/${fmt(stats.out)} \u2014 ${fmtCost(stats.cost)}
+`;
+    }
+  }
+  const { fetchOpenRouterCredits } = await import("./openrouter-credits-L45SYKT3.js");
+  const credits = await fetchOpenRouterCredits();
+  if (credits) {
+    msg += `
+\u{1F4B3} OpenRouter: $${credits.remaining.toFixed(2)} remaining ($${credits.purchased.toFixed(2)} purchased, $${credits.used.toFixed(2)} used)`;
+  }
+  await ctx.reply(msg.trim());
+  return true;
+}
+async function handleOpenRouter(_text, ctx) {
+  const { fetchOpenRouterCredits } = await import("./openrouter-credits-L45SYKT3.js");
+  const credits = await fetchOpenRouterCredits();
+  if (!credits) {
+    await ctx.reply("\u274C OpenRouter API key not set or request failed.");
+    return true;
+  }
+  await ctx.reply(
+    `\u{1F4B3} OpenRouter credits
+
+Purchased: $${credits.purchased.toFixed(2)}
+Used:      $${credits.used.toFixed(2)}
+Remaining: $${credits.remaining.toFixed(2)}`
+  );
+  return true;
+}
+async function handleWhoami(_text, ctx) {
+  const { loadUsers: loadUsers2 } = await import("./user-registry-GTAJIW6E.js");
+  const reg = loadUsers2();
+  const CLASS_NAMES = ["UNCLASSIFIED", "RESTRICTED", "CONFIDENTIAL", "SECRET"];
+  const user = ctx.userId ? reg.byUserId.get(ctx.userId) : void 0;
+  if (user) {
+    const clearance = CLASS_NAMES[user.maxClass] ?? `class ${user.maxClass}`;
+    await ctx.reply(`${user.displayName ?? user.userId} (${user.role}, ${clearance} clearance)`);
+  } else {
+    await ctx.reply(`${ctx.userId ?? "unknown"} (unregistered)`);
+  }
+  return true;
+}
+
+// src/components/nlm-command-handler.ts
+init_env_schema();
+init_logger();
+init_log_and_swallow();
+import { execFile as execFile2 } from "node:child_process";
+var TAG8 = "NLMCommand";
+var TIMEOUT_MS = 12e4;
+function loadNLMConfig() {
+  const raw = String(getEnv().notebooklmEnabled);
+  return {
+    enabled: raw === "true" || raw === "1",
+    defaultNotebook: getEnv().notebooklmDefaultNotebook
+  };
+}
+function nlmExec(args) {
+  const start = Date.now();
+  logDebug(TAG8, `nlm ${args.join(" ")}`);
+  return new Promise((resolve) => {
+    const ac = new AbortController();
+    const timer = setTimeout(() => ac.abort(), TIMEOUT_MS);
+    try {
+      execFile2("nlm", args, { signal: ac.signal, maxBuffer: 10 * 1024 * 1024 }, (err, stdout, stderr) => {
+        clearTimeout(timer);
+        logDebug(TAG8, `nlm completed in ${Date.now() - start}ms`);
+        if (err) {
+          if (err.name === "AbortError" || err.code === "ABORT_ERR") {
+            resolve({ ok: false, error: `Timeout after ${TIMEOUT_MS / 1e3}s` });
+            return;
+          }
+          resolve({ ok: false, error: stderr?.trim() || err.message });
+          return;
+        }
+        resolve({ ok: true, data: stdout.trim() });
+      });
+    } catch (err) {
+      clearTimeout(timer);
+      resolve({ ok: false, error: err instanceof Error ? err.message : String(err) });
+    }
+  });
+}
+async function handleNLMCommand(args, config) {
+  if (!config.enabled) {
+    return { text: "\u{1F4DA} Knowledge base is disabled." };
+  }
+  const parts = args.split(/\s+/).filter(Boolean);
+  const sub = parts[0] ?? "";
+  try {
+    switch (sub) {
+      case "list":
+        return await handleList();
+      case "create":
+        return await handleCreate(parts.slice(1).join(" "));
+      case "sources":
+        return await handleSources(parts[1] ?? "");
+      case "query":
+        return await handleQuery(parts.slice(1).join(" "), config);
+      default:
+        return { text: "Usage: /nlm list | /nlm create <name> | /nlm sources <notebook-id> | /nlm query <question>" };
+    }
+  } catch (err) {
+    logError(TAG8, "NLM command failed", err);
+    return { text: `\u274C NLM error: ${err instanceof Error ? err.message : String(err)}` };
+  }
+}
+async function handleList() {
+  const result = await nlmExec(["notebook", "list", "--json"]);
+  if (!result.ok) return { text: `\u274C ${result.error}` };
+  try {
+    const notebooks = JSON.parse(result.data);
+    if (!Array.isArray(notebooks) || notebooks.length === 0) return { text: "\u{1F4DA} No notebooks found." };
+    const lines = notebooks.map(
+      (n) => `\u2022 ${n.title ?? n.name ?? "?"} (${n.id ?? n.notebook_id ?? "?"})`
+    );
+    return { text: `\u{1F4DA} Notebooks:
+
+${lines.join("\n")}` };
+  } catch (err) {
+    logAndSwallow(TAG8, "JSON.parse notebook list", err);
+    return { text: `\u{1F4DA} ${result.data}` };
+  }
+}
+async function handleCreate(name) {
+  if (!name) return { text: "Usage: /nlm create <name>" };
+  const result = await nlmExec(["notebook", "create", name, "--json"]);
+  if (!result.ok) return { text: `\u274C ${result.error}` };
+  try {
+    const parsed = JSON.parse(result.data);
+    const id = parsed.notebook_id ?? parsed.id ?? "?";
+    logInfo(TAG8, `Created notebook "${name}" \u2192 ${id}`);
+    return { text: `\u2705 Notebook "${name}" created (${id})` };
+  } catch (err) {
+    logAndSwallow(TAG8, "JSON.parse notebook create", err);
+    return { text: `\u2705 ${result.data}` };
+  }
+}
+async function handleSources(notebookId) {
+  if (!notebookId) return { text: "Usage: /nlm sources <notebook-id>" };
+  const result = await nlmExec(["source", "list", notebookId, "--json"]);
+  if (!result.ok) return { text: `\u274C ${result.error}` };
+  try {
+    const sources = JSON.parse(result.data);
+    if (!Array.isArray(sources) || sources.length === 0) return { text: `\u{1F4C4} No sources in notebook.` };
+    const lines = sources.map(
+      (s) => `\u2022 [${s.type ?? s.source_type ?? "?"}] ${s.title ?? s.name ?? "?"}`
+    );
+    return { text: `\u{1F4C4} Sources:
+
+${lines.join("\n")}` };
+  } catch (err) {
+    logAndSwallow(TAG8, "JSON.parse source list", err);
+    return { text: `\u{1F4C4} ${result.data}` };
+  }
+}
+async function handleQuery(question, config) {
+  if (!question) return { text: "Usage: /nlm query <question>" };
+  const nbId = config.defaultNotebook;
+  if (!nbId) return { text: "\u274C No default notebook configured (NOTEBOOKLM_DEFAULT_NOTEBOOK)." };
+  const result = await nlmExec(["notebook", "query", nbId, question, "--json"]);
+  if (!result.ok) return { text: `\u274C ${result.error}` };
+  try {
+    const parsed = JSON.parse(result.data);
+    const answer = parsed.answer ?? parsed.response ?? result.data;
+    const sources = parsed.sources_used ?? parsed.citations ?? [];
+    const citations = Array.isArray(sources) && sources.length > 0 ? `
+
+\u{1F4CE} Sources: ${sources.map((s) => s.title ?? s.name ?? s.source_name ?? "?").join(", ")}` : "";
+    logInfo(TAG8, `Query OK \u2014 answerLen=${String(answer).length}`);
+    return { text: `\u{1F4DA} ${answer}${citations}` };
+  } catch (err) {
+    logAndSwallow(TAG8, "JSON.parse query result", err);
+    return { text: `\u{1F4DA} ${result.data}` };
+  }
+}
+
+// src/components/commands/handlers-memory.ts
+async function handleMemory(_text, ctx) {
+  if (!ctx.memory) {
+    await ctx.reply("\u{1F9E0} Memory is disabled.");
+    return true;
+  }
+  const stats = ctx.memory.getStats(ctx.userId);
+  if (!stats) {
+    await ctx.reply("\u26A0\uFE0F Could not retrieve memory stats.");
+    return true;
+  }
+  const dbMb = (stats.dbSizeBytes / (1024 * 1024)).toFixed(1);
+  const types = Object.entries(stats.extractedByType).map(([t, n]) => `  ${t}: ${n}`).join("\n") || "  (none)";
+  const msg = [
+    "\u{1F9E0} Memory Status",
+    "",
+    `\u{1F4AC} Raw messages: ${stats.totalMessages}`,
+    `\u{1F9E9} Extracted memories: ${stats.extractedMemories}`,
+    types,
+    `\u{1F511} Preserved keywords: ${stats.preservedKeywords}`,
+    "",
+    `\u{1F4C4} Consolidations:`,
+    `  daily: ${stats.consolidationFiles.daily}`,
+    `  weekly: ${stats.consolidationFiles.weekly}`,
+    `  quarterly: ${stats.consolidationFiles.quarterly}`,
+    "",
+    `\u{1F4C4} Ingested documents: ${stats.ingestedDocuments}`,
+    `\u{1F493} Heartbeat: ${stats.heartbeatRunning ? "running" : "stopped"}`,
+    `\u{1F4BE} DB size: ${dbMb} MB`,
+    "",
+    `\u{1F4DA} Layer 6 (NotebookLM): ${ctx.nlmConfig.enabled ? "enabled" : "disabled"}`
+  ].join("\n");
+  await ctx.reply(msg);
+  return true;
+}
+async function handleFacts(_text, ctx) {
+  if (ctx.memory) {
+    const facts = ctx.memory.readCoreKnowledge();
+    await ctx.reply(facts ? `\u{1F4CB} Core knowledge:
+
+${facts}` : "\u{1F4CB} No core knowledge yet.");
+  } else {
+    await ctx.reply("\u{1F9E0} Memory is disabled.");
+  }
+  return true;
+}
+async function handleNlm(text, ctx) {
+  const args = text.slice("/nlm".length).trim();
+  const result = await handleNLMCommand(args, ctx.nlmConfig);
+  await ctx.reply(result.text);
+  return true;
+}
+
+// src/components/commands/handlers-sleep.ts
+init_logger();
+init_log_and_swallow();
+init_env_schema();
+import { spawn } from "node:child_process";
+import { readFileSync as readFileSync2, readdirSync as readdirSync2, unlinkSync } from "node:fs";
+import { join as join3 } from "node:path";
+import { platform } from "node:os";
+var TAG9 = "cmd";
+async function handleSleep(_text, ctx) {
+  const sleepStatus = readBridgeLockField("sleepStatus") ?? "awake";
+  const progress = ctx.sleepProgress?.();
+  const force = readBridgeLockField("forceSleep");
+  const bedTime = getEnv().bedTime.raw;
+  const auditDir = ctx.memoryConfig?.memoryDir ? join3(ctx.memoryConfig.memoryDir, "sleep") : "";
+  const lock = auditDir ? readLatestSleepLock(auditDir) : null;
+  const lines = ["\u{1F634} Sleep status"];
+  const stateLabel = progress ? `\u{1F9E0} Sleep cycle running (${progress.step}, ${progress.percent}%)` : sleepStatus === "sleeping" ? "\u{1F634} Asleep (idle)" : sleepStatus === "hw_sleep" ? "\u{1F634} Hardware sleep" : "\u{1F44B} Awake";
+  lines.push(`  State: ${stateLabel}`);
+  if (lock) {
+    const counts = Object.values(lock.steps);
+    const ok = counts.filter((s) => s.status === "ok").length;
+    const failed = counts.filter((s) => s.status === "failed").length;
+    const skipped = counts.filter((s) => s.status === "skipped").length;
+    lines.push(`  Last cycle: ${lock.date} \u2014 ${ok} ok, ${failed} failed, ${skipped} skipped (${lock.status}, ${lock.llmCalls} LLM calls)`);
+  } else {
+    lines.push("  Last cycle: (none found)");
+  }
+  lines.push(`  Schedule: BED_TIME=${bedTime}`);
+  if (force) lines.push(`  Force-trigger: ${force}`);
+  lines.push("");
+  lines.push("/sleep resume \u2014 retry failed steps");
+  lines.push("/sleep now \u2014 full fresh cycle");
+  await ctx.reply(lines.join("\n"));
+  return true;
+}
+async function handleSleepSub(text, ctx) {
+  const sub = text.replace(/^\/sleep\s+/i, "").trim().toLowerCase();
+  const sleepStatus = readBridgeLockField("sleepStatus") ?? "awake";
+  if (sleepStatus === "sleeping") {
+    await ctx.reply("\u{1F634} Sleep already running.");
+    return true;
+  }
+  const auditDir = ctx.memoryConfig?.memoryDir ? join3(ctx.memoryConfig.memoryDir, "sleep") : "";
+  if (sub === "resume") {
+    const lock = auditDir ? readLatestSleepLock(auditDir) : null;
+    const hasFailed = lock && Object.values(lock.steps).some((s) => s.status === "failed");
+    if (!lock || lock.status === "completed" || !hasFailed) {
+      await ctx.reply("No failed sleep cycle to resume \u2014 use /sleep now for a fresh run.");
+      return true;
+    }
+    writeForceSleep("resume via /sleep resume");
+    await ctx.reply("Sleep resume queued");
+    logInfo(TAG9, "Sleep resume triggered via /sleep resume");
+    return true;
+  }
+  if (sub === "now") {
+    if (auditDir) {
+      try {
+        unlinkSync(todayLockPath(auditDir));
+      } catch (err) {
+        logAndSwallow("command_handlers", "op", err);
+      }
+    }
+    writeForceSleep("fresh via /sleep now");
+    await ctx.reply("\u26A1 Fresh sleep cycle queued \u2014 starts on next heartbeat tick (\u22645min)");
+    logInfo(TAG9, "Fresh sleep triggered via /sleep now");
+    return true;
+  }
+  await ctx.reply("Unknown subcommand. Use /sleep, /sleep resume, or /sleep now.");
+  return true;
+}
+async function handleWakeup(_text, ctx) {
+  if (readBridgeLockField("sleepStatus") !== "hw_sleep") {
+    await ctx.reply("Already awake.");
+    return true;
+  }
+  const os = platform();
+  let child = null;
+  if (os === "darwin") {
+    child = spawn("caffeinate", ["-su"], { stdio: "ignore", detached: true });
+  } else if (os === "linux") {
+    child = spawn("systemd-inhibit", ["--what=idle:sleep", "sleep", "infinity"], { stdio: "ignore", detached: true });
+  }
+  if (child?.pid) {
+    child.unref();
+    setWakeInhibitPid(child.pid);
+    writeSleepStatus("awake");
+    const bedTime = getEnv().bedTime.raw;
+    await ctx.reply(`\u2600\uFE0F Awake! Will sleep again at ${bedTime} or when requested.`);
+    logInfo("wakeup", `Emergency wake \u2014 inhibit pid=${child.pid}`);
+  } else {
+    writeSleepStatus("awake");
+    await ctx.reply("\u2600\uFE0F Awake! (sleep inhibitor not available on this platform)");
+  }
+  return true;
+}
+function readLatestSleepLock(auditDir) {
+  try {
+    const files = readdirSync2(auditDir).filter((f) => f.startsWith("sleep_") && f.endsWith(".lock")).sort();
+    if (files.length === 0) return null;
+    const latest = files[files.length - 1];
+    const raw = JSON.parse(readFileSync2(join3(auditDir, latest), "utf-8"));
+    const dateMatch = latest.match(/sleep_(\d{4})(\d{2})(\d{2})/);
+    const date = dateMatch ? `${dateMatch[1]}-${dateMatch[2]}-${dateMatch[3]}` : "unknown";
+    return { date, status: raw.status ?? "unknown", llmCalls: raw.llmCalls ?? 0, steps: raw.steps ?? {} };
+  } catch (err) {
+    logAndSwallow(TAG9, "readLastSleepAudit", err);
+    return null;
+  }
+}
+function todayLockPath(auditDir) {
+  const d = /* @__PURE__ */ new Date();
+  const ds = `${d.getFullYear()}${String(d.getMonth() + 1).padStart(2, "0")}${String(d.getDate()).padStart(2, "0")}`;
+  return join3(auditDir, `sleep_${ds}.lock`);
+}
+
+// src/components/commands/handlers-tasks.ts
+init_logger();
+init_log_and_swallow();
+var TAG10 = "cmd_tasks";
+async function handleTasksList(_text, ctx) {
+  const tz = process.env["TZ"] || Intl.DateTimeFormat().resolvedOptions().timeZone;
+  const now = (/* @__PURE__ */ new Date()).toLocaleString("en-GB", { timeZone: tz, dateStyle: "medium", timeStyle: "medium" });
+  let listing;
+  try {
+    const { readEntries: readEntries2 } = await import("./task-store-KIBFZL5A.js");
+    const entries = readEntries2();
+    const active = entries.filter((e) => !e.fired);
+    active.sort((a, b) => {
+      const timeOf = (e) => {
+        const s = e.schedule;
+        if (!s) return e.fireAt ?? 0;
+        const parts = s.split(" ");
+        return parseInt(parts[1] ?? "0", 10) * 60 + parseInt(parts[0] ?? "0", 10);
+      };
+      return timeOf(a) - timeOf(b);
+    });
+    const today = /* @__PURE__ */ new Date();
+    const dow = today.getDay();
+    const lines = active.map((e) => {
+      const sched = e.schedule ?? "one-shot";
+      let runsToday = true;
+      if (sched !== "one-shot") {
+        const parts = sched.split(" ");
+        const dowField = parts[4] ?? "*";
+        if (dowField !== "*") {
+          const allowed = /* @__PURE__ */ new Set();
+          for (const seg of dowField.split(",")) {
+            if (seg.includes("-")) {
+              const [a, b] = seg.split("-").map(Number);
+              for (let i = a; i <= b; i++) allowed.add(i);
+            } else allowed.add(Number(seg));
+          }
+          runsToday = allowed.has(dow);
+        }
+      }
+      const succeeded = e.history?.some((h) => h.exitCode === 0 && new Date(h.ts).toDateString() === today.toDateString());
+      const failed = e.history?.some((h) => h.exitCode !== void 0 && h.exitCode !== 0 && new Date(h.ts).toDateString() === today.toDateString());
+      const started = e.lastRanAt && new Date(e.lastRanAt).toDateString() === today.toDateString();
+      const running2 = ctx.cronCurrentJob?.entryId === e.id;
+      const tick = e.paused ? "\u23F8" : !runsToday ? "\u2014" : succeeded ? "\u2713" : running2 ? "~" : failed ? "\u2717" : started ? "\u2717" : "+";
+      const label = e.title || e.message.split("\n")[0].replace(/[~\/][\w.\/-]+\//g, "").slice(0, 30);
+      return `${tick}  ${e.id.padEnd(22)}${sched.padEnd(16)}${label}`;
+    });
+    listing = lines.length > 0 ? "<pre>" + lines.join("\n") + "</pre>" : "(no active entries)";
+  } catch (err) {
+    logError("tasks", `Failed to read cron: ${err instanceof Error ? err.message : String(err)}`);
+    listing = "(no active entries)";
+  }
+  let running = "";
+  if (ctx.cronCurrentJob) {
+    const j = ctx.cronCurrentJob;
+    const ago = Math.round((Date.now() - j.startedAt) / 1e3);
+    running = `
+\u25B6 Running: ${j.type} (pid ${j.pid}, ${ago}s ago)
+   ${j.entryId}`;
+  }
+  await ctx.reply(`\u23F0 ${now}
+
+${listing}${running}`, { parseMode: "HTML" });
+  return true;
+}
+async function handleTasksTrigger(text, ctx) {
+  const id = text.replace(/^\/(tasks?|cron) run /, "").trim();
+  if (!id) {
+    await ctx.reply("Usage: /task run <cron-id>");
+    return true;
+  }
+  const err = ctx.enqueueCron?.(id, true);
+  await ctx.reply(err ?? `\u23F3 Running: ${id}`);
+  return true;
+}
+async function handleTasksLog(text, ctx) {
+  const id = text.replace(/^\/(tasks?|cron) log /, "").trim();
+  const placeholderId = await ctx.reply("\u{1F4CB} Loading task log...");
+  try {
+    const raw = await execAsync("abtars-task", ["history", id], 5e3);
+    if (!raw) throw new Error("empty");
+    const data = JSON.parse(raw);
+    if (!data.ok) {
+      const msg = `\u274C ${data.error}`;
+      if (placeholderId !== void 0 && ctx.editReply) await ctx.editReply(placeholderId, msg);
+      else await ctx.reply(msg);
+      return true;
+    }
+    const runs = data.runs.slice(-5);
+    const lines = runs.map((r) => `${r.ranAt}  exit=${r.exitCode ?? "?"}`);
+    const body = `\u{1F4CB} ${data.message}
+
+\`\`\`
+${lines.join("\n") || "(no runs)"}
+\`\`\``;
+    if (placeholderId !== void 0 && ctx.editReply) await ctx.editReply(placeholderId, body);
+    else await ctx.reply(body, { parseMode: "Markdown" });
+  } catch (err) {
+    logAndSwallow(TAG10, "read task history", err);
+    const msg = "\u274C Failed to read history";
+    if (placeholderId !== void 0 && ctx.editReply) await ctx.editReply(placeholderId, msg);
+    else await ctx.reply(msg);
+  }
+  return true;
+}
+async function handleTaskPause(text, ctx) {
+  const match = text.match(/^\/(tasks?|cron)\s+(pause|resume)\s+(.+)/i);
+  if (!match) {
+    await ctx.reply("Usage: /task pause|resume <id>");
+    return true;
+  }
+  const action = match[2].toLowerCase();
+  const id = match[3].trim();
+  try {
+    const raw = await execAsync("abtars-task", [action, id], 5e3);
+    const data = JSON.parse(raw || "{}");
+    await ctx.reply(data.ok ? `\u2713 ${id} ${action}d` : `\u274C ${data.error ?? "unknown error"}`);
+  } catch (err) {
+    await ctx.reply(`\u274C Failed: ${err instanceof Error ? err.message : String(err)}`);
+  }
+  return true;
+}
+
+// src/components/commands/handlers-admin.ts
+init_log_and_swallow();
+init_paths();
+import { readdirSync as readdirSync3 } from "node:fs";
+import { join as join4 } from "node:path";
+var TAG11 = "cmd_admin";
+async function handleUsers(text, ctx) {
+  const { loadUsers: loadUsers2 } = await import("./user-registry-GTAJIW6E.js");
+  const parts = text.trim().split(/\s+/);
+  const sub = parts[1];
+  if (sub === "approve" && parts[2]) {
+    const platformId = parts[2];
+    const { writeFileSync: writeFileSync2, readFileSync: readFileSync3 } = await import("node:fs");
+    const { join: join5 } = await import("node:path");
+    const { abtarsHome: abtarsHome2 } = await import("./paths-ZJYIDND2.js");
+    const configPath = join5(abtarsHome2(), "config", "users.json");
+    try {
+      const raw = JSON.parse(readFileSync3(configPath, "utf-8"));
+      const users = Array.isArray(raw.users) ? raw.users : [];
+      if (users.some((u) => String(u.platforms?.telegram) === platformId)) {
+        await ctx.reply(`User with platform ID ${platformId} already exists.`);
+        return true;
+      }
+      const guestId = `guest-${platformId}`;
+      users.push({ userId: guestId, role: "guest", maxClass: 0, tools: [], platforms: { telegram: parseInt(platformId, 10) || 0 } });
+      writeFileSync2(configPath, JSON.stringify({ users }, null, 2), "utf-8");
+      await ctx.reply(`\u2705 Approved guest: ${guestId} (platform ID: ${platformId})`);
+    } catch (err) {
+      await ctx.reply(`\u274C Failed: ${err instanceof Error ? err.message : String(err)}`);
+    }
+    return true;
+  }
+  if (sub === "revoke" && parts[2]) {
+    const targetUserId = parts[2];
+    const { writeFileSync: writeFileSync2, readFileSync: readFileSync3 } = await import("node:fs");
+    const { join: join5 } = await import("node:path");
+    const { abtarsHome: abtarsHome2 } = await import("./paths-ZJYIDND2.js");
+    const configPath = join5(abtarsHome2(), "config", "users.json");
+    try {
+      const raw = JSON.parse(readFileSync3(configPath, "utf-8"));
+      const users = (Array.isArray(raw.users) ? raw.users : []).filter((u) => u.userId !== targetUserId);
+      writeFileSync2(configPath, JSON.stringify({ users }, null, 2), "utf-8");
+      await ctx.reply(`\u2705 Revoked: ${targetUserId}`);
+    } catch (err) {
+      await ctx.reply(`\u274C Failed: ${err instanceof Error ? err.message : String(err)}`);
+    }
+    return true;
+  }
+  const registry = loadUsers2();
+  const CLASS_NAMES = ["UNCLASSIFIED", "RESTRICTED", "CONFIDENTIAL", "SECRET"];
+  const lines = registry.users.map(
+    (u) => `\u2022 ${u.userId} (${u.role}, ${CLASS_NAMES[u.maxClass] ?? `class ${u.maxClass}`}) \u2014 tools: ${u.tools.join(", ") || "none"}`
+  );
+  await ctx.reply(`\u{1F465} Users (${registry.users.length}):
+${lines.join("\n")}
+
+/users approve <platformId>
+/users revoke <userId>`);
+  return true;
+}
+async function handleSkills(_text, ctx) {
+  const base = join4(abtarsHome(), "skills");
+  const groups = ["core", "personal", "auto", "downloaded"];
+  const sections = [];
+  let total = 0;
+  for (const group of groups) {
+    const dir = join4(base, group);
+    try {
+      const files = readdirSync3(dir, { recursive: true }).map((f) => String(f)).filter((f) => f.endsWith(".md") && !f.endsWith("TOOLS.md")).sort();
+      if (files.length > 0) {
+        total += files.length;
+        sections.push(`${group} (${files.length}):
+${files.map((f) => `  \u2022 ${f.replace(/\.md$/, "")}`).join("\n")}`);
+      }
+    } catch (err) {
+      logAndSwallow("command_handlers", "op", err);
+    }
+  }
+  await ctx.reply(total > 0 ? `\u{1F4DA} Skills (${total}):
+
+${sections.join("\n\n")}` : "\u{1F4DA} No skills found.");
+  return true;
+}
+async function handleHooks(_text, ctx) {
+  const { getHookSummary } = await import("./hook-system-POI5VRIX.js");
+  const summary = getHookSummary();
+  const lines = ["\u{1FA9D} Hooks:"];
+  for (const { event, hooks } of summary) {
+    if (hooks.length === 0) {
+      lines.push(`  ${event}: (none)`);
+    } else {
+      lines.push(`  ${event}: ${hooks.map((h) => `${h.name} (${h.timeout ?? 5e3}ms)`).join(", ")}`);
+    }
+  }
+  await ctx.reply(lines.join("\n"));
+  return true;
+}
+async function handleMcp(_text, ctx) {
+  const arg = _text.replace(/^\/mcp\s*/i, "").trim().toLowerCase();
+  if (arg === "start") {
+    const { loadUsers: loadUsers2 } = await import("./user-registry-GTAJIW6E.js");
+    const registry = loadUsers2();
+    const user = registry.byUserId.get(ctx.userId);
+    if (user?.role !== "master") {
+      await ctx.reply("\u274C /mcp start is master-only.");
+      return true;
+    }
+    const result = await execAsync("mcporter", ["daemon", "start"], 1e4);
+    await ctx.reply(result ? `\u{1F4E6} mcporter daemon started.
+${result}` : "\u{1F4E6} mcporter daemon start failed.");
+    return true;
+  }
+  let version = await execAsync("mcporter", ["--version"], 2e3);
+  if (version === null) {
+    await ctx.reply("\u{1F4E6} mcporter not installed");
+    return true;
+  }
+  if (!version) version = "unknown";
+  const placeholderId = await ctx.reply("\u{1F4E6} Checking MCP servers...");
+  const raw = await execAsync("mcporter", ["list", "--json"], 15e3);
+  let body;
+  if (!raw) {
+    body = `\u{1F4E6} MCP: mcporter installed (${version.split("\n")[0]}) but list failed`;
+  } else {
+    try {
+      const data = JSON.parse(raw);
+      const servers = data.servers ?? [];
+      const ok = servers.filter((s) => s.status === "ok").length;
+      const lines = [
+        "\u{1F4E6} MCP status",
+        `  mcporter: installed (${version.split("\n")[0]})`,
+        `  Servers: ${ok}/${servers.length} online`
+      ];
+      for (const s of servers) {
+        const mark = s.status === "ok" ? "\u2713" : "\u2717";
+        const toolCount = Array.isArray(s.tools) ? s.tools.length : s.tools ?? 0;
+        const detail = s.status === "ok" ? `tools: ${toolCount}${s.prompts ? `, prompts: ${s.prompts}` : ""}` : s.error ?? s.status ?? "error";
+        lines.push(`    ${mark} ${s.name ?? "?"} (${detail})`);
+      }
+      body = lines.join("\n");
+    } catch (err) {
+      logAndSwallow(TAG11, "JSON.parse mcp list", err);
+      body = "\u{1F4E6} MCP: installed, list output unparseable";
+    }
+  }
+  if (placeholderId !== void 0 && ctx.editReply) {
+    await ctx.editReply(placeholderId, body);
+  } else {
+    await ctx.reply(body);
+  }
+  return true;
+}
+async function handleHelp(_text, ctx) {
+  const cmds = [
+    "/reset \u2014 Reload transport + fresh session",
+    "/reset default \u2014 Restore transport.default.json + fresh session",
+    "/compact \u2014 Compact context window (summarize + fresh session)",
+    "/status \u2014 Bridge status, transport, heartbeat",
+    "/doctor \u2014 Deep probe all subsystems",
+    "/doctor fix \u2014 Run safe auto-repairs",
+    "/doctor fix-full \u2014 Full repair (+ FTS rebuild, WAL checkpoint)",
+    "/mcp \u2014 MCP server status",
+    "/hooks \u2014 List configured hooks",
+    "/stop, /ctrlc \u2014 Stop current response",
+    "/memory \u2014 Memory storage statistics",
+    "/heartbeat \u2014 Heartbeat diagnostics (tasks, last tick)",
+    "/models \u2014 Model, transport & agent status",
+    "/models change \u2014 Switch model/provider (any agent)",
+    "/models quick <model> \u2014 Instant switch on same provider",
+    "/models list [provider] \u2014 List providers or models on a provider",
+    "/models restore \u2014 Undo last model/provider switch",
+    "/models default \u2014 Factory reset (transport.default.json)",
+    "/models emergency \u2014 \u{1F6A8} Activate paid hailMary model (manual)",
+    "/emergency \u2014 Shortcut for /models emergency",
+    "/models health reset \u2014 Reset model health buckets",
+    "/tasks \u2014 Scheduled tasks",
+    "/tasks log <id> \u2014 Last 5 runs for a task",
+    "/task run <id> \u2014 Manually fire a task",
+    "/task pause <id> \u2014 Pause a task",
+    "/task resume <id> \u2014 Resume a paused task",
+    "/facts \u2014 Core knowledge (user profile + agent notes)",
+    "/skills \u2014 List loaded skills",
+    "/session \u2014 List sessions",
+    "/session new [browse|code|task] \u2014 New session",
+    "/session <#> \u2014 Switch session",
+    "/session end [#] \u2014 End session (keep messages)",
+    "/session kill <#> \u2014 Kill session (wipe messages)",
+    "/default \u2014 Switch back to default agent",
+    "/nlm \u2014 Knowledge base (list/create/sources/query)",
+    "/restart \u2014 Restart CLI session",
+    "/wakeup \u2014 Wake Mac from sleep (cancel hw_sleep)",
+    "/sleep \u2014 Sleep status",
+    "/sleep resume \u2014 Retry failed sleep steps",
+    "/sleep now \u2014 Full fresh sleep cycle",
+    "/skill reload \u2014 Regenerate skills catalog"
+  ];
+  if (ctx.platform === "telegram") {
+    cmds.push("/full \u2014 Raw output, TTS disabled", "/short \u2014 Clean responses (default)", "/healing \u2014 Toggle self-healer on/off");
+  }
+  cmds.push("/help \u2014 Show this help");
+  cmds.push("/skills \u2014 List available skills");
+  await ctx.reply(`\u{1F4CB} Available commands:
+
+${cmds.join("\n")}`);
+  return true;
+}
+
+// src/components/commands/session-handler.ts
+init_logger();
+init_log_and_swallow();
+
+// src/components/session-manager.ts
+var TYPE_LABELS = { A: "Main", B: "Browse", C: "Code", T: "Task", P: "Peer", S: "System" };
+var TYPE_AGENT = { C: "coding", B: "browsie", P: "coding", S: "coding" };
+function typeLabel(t) {
+  return TYPE_LABELS[t];
+}
+function parseSessionType(input) {
+  switch (input.toLowerCase()) {
+    case "browse":
+      return "B";
+    case "code":
+      return "C";
+    case "task":
+      return "T";
+    default:
+      return null;
+  }
+}
+var SessionManager = class {
+  states = /* @__PURE__ */ new Map();
+  // key = "userId:platform"
+  maxSessions;
+  runtime = null;
+  constructor(maxSessions = 10) {
+    this.maxSessions = maxSessions;
+  }
+  /** Set runtime (called after boot phase creates it). */
+  setRuntime(runtime) {
+    this.runtime = runtime;
+  }
+  stateKey(userId, platform2) {
+    return `${userId}:${platform2}`;
+  }
+  getOrCreateState(userId, platform2) {
+    const key = this.stateKey(userId, platform2);
+    let state = this.states.get(key);
+    if (!state) {
+      state = { sessions: [], activeIndex: 1, nextIndex: 1 };
+      this.states.set(key, state);
+      const main = this.allocateSession(state, "A", true);
+      state.activeIndex = main.shortIndex;
+    }
+    return state;
+  }
+  allocateSession(state, type, isTransport, motherId) {
+    const idx = state.nextIndex++;
+    const ts = Math.floor(Date.now() / 1e3);
+    const session = {
+      id: `${ts}_${type}_${String(idx).padStart(2, "0")}`,
+      shortIndex: idx,
+      type,
+      createdAt: Date.now(),
+      isTransport,
+      ended: false,
+      paused: false,
+      motherId
+    };
+    state.sessions.push(session);
+    return session;
+  }
+  /** Get or create the initial main session. Returns its session ID. */
+  getActiveSessionId(userId, platform2) {
+    const state = this.getOrCreateState(userId, platform2);
+    const active = state.sessions.find((s) => s.shortIndex === state.activeIndex && !s.ended);
+    return active?.id ?? state.sessions[0].id;
+  }
+  /** Get the active session entry. */
+  getActiveSession(userId, platform2) {
+    const state = this.getOrCreateState(userId, platform2);
+    return state.sessions.find((s) => s.shortIndex === state.activeIndex && !s.ended) ?? state.sessions[0];
+  }
+  /** Initialize agent session for non-Main types. Returns the AgentSession or null. */
+  async initAgentSession(session) {
+    const agentName = TYPE_AGENT[session.type];
+    if (!agentName || !this.runtime) return null;
+    if (session.agentSession) return session.agentSession;
+    session.agentSession = await this.runtime.session(agentName);
+    return session.agentSession;
+  }
+  /** Create a new transport session. Returns the session or error string. */
+  createSession(userId, platform2, type) {
+    const state = this.getOrCreateState(userId, platform2);
+    const alive = state.sessions.filter((s) => !s.ended);
+    if (alive.length >= this.maxSessions) {
+      return `Max sessions reached (${this.maxSessions}). End or kill a session first.`;
+    }
+    const session = this.allocateSession(state, type, true);
+    state.activeIndex = session.shortIndex;
+    return session;
+  }
+  /** Create a sub-session ID for auto-spawn (storage tag only, no transport switch). */
+  createSubSession(userId, platform2, type) {
+    const state = this.getOrCreateState(userId, platform2);
+    const alive = state.sessions.filter((s) => !s.ended);
+    if (alive.length >= this.maxSessions) {
+      return `Max sessions reached \u2014 auto-spawn skipped.`;
+    }
+    const active = state.sessions.find((s) => s.shortIndex === state.activeIndex && !s.ended);
+    return this.allocateSession(state, type, false, active?.id);
+  }
+  /** Switch active transport session. Returns session or error. */
+  switchSession(userId, platform2, index) {
+    const state = this.getOrCreateState(userId, platform2);
+    const target = state.sessions.find((s) => s.shortIndex === index && !s.ended && s.isTransport);
+    if (!target) return `Session #${index} not found or not switchable.`;
+    state.activeIndex = target.shortIndex;
+    return target;
+  }
+  /** Gracefully end a session (keeps messages). Returns ended session or error. */
+  endSession(userId, platform2, index) {
+    const state = this.getOrCreateState(userId, platform2);
+    const targetIdx = index ?? state.activeIndex;
+    const target = state.sessions.find((s) => s.shortIndex === targetIdx && !s.ended);
+    if (!target) return `Session #${targetIdx} not found.`;
+    const aliveMains = state.sessions.filter((s) => s.type === "A" && !s.ended);
+    if (target.type === "A" && aliveMains.length <= 1) {
+      target.ended = true;
+      const newMain = this.allocateSession(state, "A", true);
+      state.activeIndex = newMain.shortIndex;
+      return target;
+    }
+    target.ended = true;
+    if (state.activeIndex === targetIdx) {
+      const main = state.sessions.find((s) => s.type === "A" && !s.ended);
+      state.activeIndex = main?.shortIndex ?? 1;
+    }
+    return target;
+  }
+  /** Kill a session (wipe messages). Returns killed session or error. */
+  killSession(userId, platform2, index) {
+    const state = this.getOrCreateState(userId, platform2);
+    const target = state.sessions.find((s) => s.shortIndex === index && !s.ended);
+    if (!target) return `Session #${index} not found.`;
+    if (state.activeIndex === index) {
+      const otherMain = state.sessions.find((s) => s.type === "A" && !s.ended && s.shortIndex !== index);
+      if (otherMain) {
+        state.activeIndex = otherMain.shortIndex;
+      } else {
+        target.ended = true;
+        const newMain = this.allocateSession(state, "A", true);
+        state.activeIndex = newMain.shortIndex;
+        return target;
+      }
+    } else {
+      const aliveMains = state.sessions.filter((s) => s.type === "A" && !s.ended);
+      if (target.type === "A" && aliveMains.length <= 1) {
+        target.ended = true;
+        this.allocateSession(state, "A", true);
+        return target;
+      }
+    }
+    target.ended = true;
+    return target;
+  }
+  /** List all sessions for a user+platform. */
+  listSessions(userId, platform2) {
+    const state = this.getOrCreateState(userId, platform2);
+    return { sessions: state.sessions.filter((s) => !s.ended), activeIndex: state.activeIndex };
+  }
+  /** Find a session by ID across all platforms. */
+  getSessionById(sessionId) {
+    for (const state of this.states.values()) {
+      const found = state.sessions.find((s) => s.id === sessionId);
+      if (found) return found;
+    }
+    return void 0;
+  }
+  /** Pause a session (cooperative interrupt — agent loop stops between tool calls). */
+  pauseSession(userId, platform2, index) {
+    const state = this.getOrCreateState(userId, platform2);
+    const targetIdx = index ?? state.activeIndex;
+    const target = state.sessions.find((s) => s.shortIndex === targetIdx && !s.ended);
+    if (!target) return `Session #${targetIdx} not found.`;
+    if (target.paused) return `Session #${targetIdx} is already paused.`;
+    target.paused = true;
+    return target;
+  }
+  /** Resume a paused session. */
+  resumeSession(userId, platform2, index) {
+    const state = this.getOrCreateState(userId, platform2);
+    const targetIdx = index ?? state.activeIndex;
+    const target = state.sessions.find((s) => s.shortIndex === targetIdx && !s.ended);
+    if (!target) return `Session #${targetIdx} not found.`;
+    if (!target.paused) return `Session #${targetIdx} is not paused.`;
+    target.paused = false;
+    return target;
+  }
+  /** End auto-spawn sessions that have been inactive. */
+  expireAutoSessions(timeoutMs) {
+    const expired = [];
+    const cutoff = Date.now() - timeoutMs;
+    for (const state of this.states.values()) {
+      for (const s of state.sessions) {
+        if (!s.ended && !s.isTransport && s.createdAt < cutoff) {
+          s.ended = true;
+          expired.push(s);
+        }
+      }
+    }
+    return expired;
+  }
+  /** Clear all sessions for a platform (transport destruction). */
+  clearPlatform(userId, platform2) {
+    this.states.delete(this.stateKey(userId, platform2));
+  }
+  /** Clear everything (bridge restart). */
+  clearAll() {
+    this.states.clear();
+  }
+  /** Format session list for display. */
+  formatList(userId, platform2) {
+    const { sessions, activeIndex } = this.listSessions(userId, platform2);
+    if (sessions.length === 0) return "No active sessions.";
+    const lines = sessions.map((s) => {
+      const marker = s.shortIndex === activeIndex ? " *" : "";
+      const transport = s.isTransport ? "" : " (sub)";
+      const paused = s.paused ? " \u23F8" : "";
+      const mother = s.motherId ? ` \u2190 #${this.getSessionById(s.motherId)?.shortIndex ?? "?"}` : "";
+      const time = new Date(s.createdAt).toLocaleTimeString("en-GB", { hour: "2-digit", minute: "2-digit" });
+      return `#${s.shortIndex} ${typeLabel(s.type)}${transport}${mother} \u2014 ${time}${paused}${marker}`;
+    });
+    return lines.join("\n");
+  }
+};
+
+// src/components/commands/session-handler.ts
+var TAG12 = "cmd:session";
+async function handleSession(text, ctx) {
+  const args = text.replace(/^\/session\s*/i, "").trim();
+  if (!args) {
+    await ctx.reply(ctx.sessionManager.formatList(ctx.userId, ctx.platform));
+    return true;
+  }
+  if (args.startsWith("new")) {
+    const typeArg = args.slice(3).trim();
+    const type = typeArg ? parseSessionType(typeArg) : "A";
+    if (!type) {
+      await ctx.reply(`Unknown session type: ${typeArg}. Available: browse, code, task`);
+      return true;
+    }
+    const result = ctx.sessionManager.createSession(ctx.userId, ctx.platform, type);
+    if (typeof result === "string") {
+      await ctx.reply(`\u274C ${result}`);
+      return true;
+    }
+    await ctx.sessionManager.initAgentSession(result);
+    await ctx.reply(`\u2705 Session #${result.shortIndex} (${typeLabel(result.type)}) created.`);
+    logInfo(TAG12, `New session ${result.id} for ${ctx.userId}`);
+    return true;
+  }
+  if (args.startsWith("end")) {
+    const indexStr = args.slice(3).trim();
+    const index2 = indexStr ? parseInt(indexStr, 10) : void 0;
+    if (indexStr && isNaN(index2)) {
+      await ctx.reply("Usage: /session end [#]");
+      return true;
+    }
+    const result = ctx.sessionManager.endSession(ctx.userId, ctx.platform, index2);
+    if (typeof result === "string") {
+      await ctx.reply(`\u274C ${result}`);
+      return true;
+    }
+    await ctx.reply(`\u2705 Session #${result.shortIndex} (${typeLabel(result.type)}) ended.`);
+    logInfo(TAG12, `Ended session ${result.id}`);
+    return true;
+  }
+  if (args.startsWith("kill")) {
+    const indexStr = args.slice(4).trim();
+    const index2 = parseInt(indexStr, 10);
+    if (isNaN(index2)) {
+      await ctx.reply("Usage: /session kill <#>");
+      return true;
+    }
+    const result = ctx.sessionManager.killSession(ctx.userId, ctx.platform, index2);
+    if (typeof result === "string") {
+      await ctx.reply(`\u274C ${result}`);
+      return true;
+    }
+    if (ctx.memory) {
+      try {
+        const db = ctx.memory.db;
+        if (db) db.prepare("DELETE FROM messages WHERE session_id = ?").run(result.id);
+      } catch (err) {
+        logAndSwallow(TAG12, "delete session messages", err);
+      }
+    }
+    await ctx.reply(`\u{1F5D1}\uFE0F Session #${result.shortIndex} (${typeLabel(result.type)}) killed.`);
+    logInfo(TAG12, `Killed session ${result.id}`);
+    return true;
+  }
+  if (args.startsWith("pause")) {
+    const indexStr = args.slice(5).trim();
+    const index2 = indexStr ? parseInt(indexStr, 10) : void 0;
+    if (indexStr && isNaN(index2)) {
+      await ctx.reply("Usage: /session pause [#]");
+      return true;
+    }
+    const result = ctx.sessionManager.pauseSession(ctx.userId, ctx.platform, index2);
+    if (typeof result === "string") {
+      await ctx.reply(`\u274C ${result}`);
+      return true;
+    }
+    await ctx.reply(`\u23F8 Session #${result.shortIndex} (${typeLabel(result.type)}) paused.`);
+    logInfo(TAG12, `Paused session ${result.id}`);
+    return true;
+  }
+  if (args.startsWith("resume")) {
+    const indexStr = args.slice(6).trim();
+    const index2 = indexStr ? parseInt(indexStr, 10) : void 0;
+    if (indexStr && isNaN(index2)) {
+      await ctx.reply("Usage: /session resume [#]");
+      return true;
+    }
+    const result = ctx.sessionManager.resumeSession(ctx.userId, ctx.platform, index2);
+    if (typeof result === "string") {
+      await ctx.reply(`\u274C ${result}`);
+      return true;
+    }
+    await ctx.reply(`\u25B6\uFE0F Session #${result.shortIndex} (${typeLabel(result.type)}) resumed.`);
+    logInfo(TAG12, `Resumed session ${result.id}`);
+    return true;
+  }
+  const index = parseInt(args, 10);
+  if (!isNaN(index)) {
+    const result = ctx.sessionManager.switchSession(ctx.userId, ctx.platform, index);
+    if (typeof result === "string") {
+      await ctx.reply(`\u274C ${result}`);
+      return true;
+    }
+    await ctx.reply(`\u{1F500} Switched to session #${result.shortIndex} (${typeLabel(result.type)}).`);
+    logInfo(TAG12, `Switched to session ${result.id}`);
+    return true;
+  }
+  await ctx.reply("Usage: /session [new [browse|code|task] | end [#] | kill <#> | pause [#] | resume [#] | <#>]");
+  return true;
+}
+
+// src/components/commands/index.ts
+registerExact("/reset", handleNewReset);
+registerExact("/compact", handleCompact);
+registerExact("/status", handleStatus);
+registerExact("/doctor", handleDoctor);
+registerExact("/stop", handleStop);
+registerExact("/ctrlc", handleStop);
+registerExact("/wait", handleWait);
+registerExact("/steer", handleWait);
+registerExact("/restart", handleRestart);
+registerExact("/full", handleFull);
+registerExact("/short", handleShort);
+registerExact("/healing", handleHealing);
+registerExact("/facts", handleFacts);
+registerExact("/tasks", handleTasksList);
+registerExact("/task", handleTasksList);
+registerExact("/cron", handleTasksList);
+registerExact("/memory", handleMemory);
+registerExact("/heartbeat", handleHeartbeat);
+registerExact("/models", handleModels);
+registerExact("/model", handleModels);
+registerExact("/change", (_, ctx) => handleModels("/model change", ctx));
+registerExact("/emergency", handleEmergencyAlias);
+registerExact("/help", handleHelp);
+registerExact("/users", handleUsers);
+registerExact("/skills", handleSkills);
+registerExact("/skill", handleSkills);
+registerExact("/wakeup", handleWakeup);
+registerExact("/sleep", handleSleep);
+registerExact("/mcp", handleMcp);
+registerExact("/hooks", handleHooks);
+registerExact("/usage", handleUsage);
+registerExact("/openrouter", handleOpenRouter);
+registerExact("/whoami", handleWhoami);
+registerExact("/session", handleSession);
+registerPrefix("/session ", handleSession);
+registerPrefix("/tasks run ", handleTasksTrigger);
+registerPrefix("/task run ", handleTasksTrigger);
+registerPrefix("/cron run ", handleTasksTrigger);
+registerPrefix("/tasks log ", handleTasksLog);
+registerPrefix("/task log ", handleTasksLog);
+registerPrefix("/cron log ", handleTasksLog);
+registerPrefix("/nlm", handleNlm);
+registerPrefix("/sleep ", handleSleepSub);
+registerPrefix("/usage ", handleUsage);
+registerPrefix("/task pause ", handleTaskPause);
+registerPrefix("/task resume ", handleTaskPause);
+registerPrefix("/tasks pause ", handleTaskPause);
+registerPrefix("/tasks resume ", handleTaskPause);
+
+export {
+  SessionRegistry,
+  SessionManager,
+  loadNLMConfig,
+  sanitizeOutbound,
+  routeReaction,
+  formatReactionSignal,
+  cleanResponse,
+  registerCommand,
+  handleCommand,
+  triggerNewSession,
+  triggerResetSession,
+  killWakeInhibit,
+  resetIdleCompactFlag,
+  setIdleCompactReset,
+  resetAndPrepare,
+  handleInboundMessage,
+  startSession
+};
+//# sourceMappingURL=chunk-TXRWQIQQ.js.map