blun-king-cli 9.1.587 → 9.1.588

package/bin/telegram-queue-handoff-policy.cjs

@@ -1,73 +0,0 @@
-'use strict';
-
-function queueFileIdentity(stats) {
-  if (!stats) return '';
-  return `${stats.dev}:${stats.ino}:${stats.birthtimeMs}`;
-}
-
-function captureTelegramQueueBaseline(stats) {
-  const fileId = queueFileIdentity(stats);
-  const offset = Number(stats?.size);
-  if (!fileId || !Number.isSafeInteger(offset) || offset < 0) {
-    return { fileId: '', offset: 0 };
-  }
-  return { fileId, offset };
-}
-
-function validCheckpoint(checkpoint, queueFileId, queueSize) {
-  return checkpoint?.version === 1
-    && checkpoint.fileId === queueFileId
-    && Number.isSafeInteger(checkpoint.offset)
-    && checkpoint.offset >= 0
-    && checkpoint.offset <= queueSize;
-}
-
-function resolveTelegramQueueActivationOffset(input) {
-  const queueFileId = String(input?.queueFileId ?? '');
-  const queueSize = Number(input?.queueSize);
-  const baseline = input?.baseline;
-  if (!queueFileId || !Number.isSafeInteger(queueSize) || queueSize < 0) {
-    return { offset: 0, reason: 'queue_unavailable' };
-  }
-  if (validCheckpoint(input?.checkpoint, queueFileId, queueSize)) {
-    return { offset: input.checkpoint.offset, reason: 'checkpoint' };
-  }
-  if (
-    baseline?.fileId === queueFileId
-    && Number.isSafeInteger(baseline.offset)
-    && baseline.offset >= 0
-    && baseline.offset <= queueSize
-  ) {
-    return { offset: baseline.offset, reason: 'ownership_baseline' };
-  }
-  return { offset: 0, reason: 'queue_replaced' };
-}
-
-function resolveTelegramQueueCheckpointWrite(input) {
-  const queueFileId = String(input?.queueFileId ?? '');
-  const queueSize = Number(input?.queueSize);
-  const requestedOffset = Number(input?.requestedOffset);
-  if (
-    !queueFileId
-    || !Number.isSafeInteger(queueSize)
-    || queueSize < 0
-    || !Number.isSafeInteger(requestedOffset)
-    || requestedOffset < 0
-    || requestedOffset > queueSize
-  ) {
-    return { offset: 0, reason: 'invalid' };
-  }
-  if (
-    validCheckpoint(input?.currentCheckpoint, queueFileId, queueSize)
-    && input.currentCheckpoint.offset > requestedOffset
-  ) {
-    return { offset: input.currentCheckpoint.offset, reason: 'monotonic_current' };
-  }
-  return { offset: requestedOffset, reason: 'requested' };
-}
-
-module.exports = {
-  captureTelegramQueueBaseline,
-  resolveTelegramQueueCheckpointWrite,
-  resolveTelegramQueueActivationOffset,
-};

package/bin/telegram-remote-status-policy.cjs

@@ -1,120 +0,0 @@
-'use strict';
-
-const STABLE_VERSION_RE = /^(?:0|[1-9]\d*)\.(?:0|[1-9]\d*)\.(?:0|[1-9]\d*)$/u;
-
-function trustedVersion(value) {
-  const version = typeof value === 'string' ? value.trim() : '';
-  return STABLE_VERSION_RE.test(version) ? version : undefined;
-}
-
-function resolveTelegramRemoteVersion(input = {}) {
-  return trustedVersion(input.activeRuntimeVersion)
-    || trustedVersion(input.bridgePackageVersion)
-    || 'unbekannt';
-}
-
-function resolveVersionDisplay(input = {}) {
-  const loaded = trustedVersion(input.consoleStatus?.loadedVersion)
-    || trustedVersion(input.version)
-    || 'unbekannt';
-  const installed = trustedVersion(input.installedVersion);
-  return installed !== undefined && installed !== loaded
-    ? `${loaded} -> ${installed}`
-    : loaded;
-}
-
-function formatDuration(seconds) {
-  const minutes = Math.max(0, Math.floor(Number(seconds) / 60));
-  if (minutes < 60) return `${minutes} min`;
-  const hours = Math.floor(minutes / 60);
-  return `${hours} h ${minutes % 60} min`;
-}
-
-function formatBytes(bytes) {
-  const value = Math.max(0, Number(bytes) || 0);
-  if (value < 1024) return `${Math.round(value)} B`;
-  if (value < 1024 * 1024) return `${(value / 1024).toFixed(1).replace('.', ',')} KB`;
-  return `${(value / (1024 * 1024)).toFixed(1).replace('.', ',')} MB`;
-}
-
-function formatAge(value, capturedAt) {
-  const then = Date.parse(value);
-  const now = Date.parse(capturedAt);
-  if (!Number.isFinite(then) || !Number.isFinite(now) || then > now) return undefined;
-  const seconds = Math.floor((now - then) / 1000);
-  return seconds < 60 ? `vor ${seconds} s` : `vor ${formatDuration(seconds)}`;
-}
-
-function resolveTelegramQueueSnapshot(input = {}) {
-  const totalBytes = Number.isSafeInteger(input.queueBytes) && input.queueBytes >= 0
-    ? input.queueBytes
-    : 0;
-  const checkpoint = input.checkpoint;
-  const checkpointValid = checkpoint?.version === 1
-    && typeof input.queueFileId === 'string'
-    && input.queueFileId.length > 0
-    && checkpoint.fileId === input.queueFileId
-    && Number.isSafeInteger(checkpoint.offset)
-    && checkpoint.offset >= 0
-    && checkpoint.offset <= totalBytes;
-  return {
-    totalBytes,
-    unreadBytes: checkpointValid ? totalBytes - checkpoint.offset : undefined,
-    checkpointValid,
-  };
-}
-
-function buildTelegramRemoteStatus(input) {
-  if (!input?.access?.allowFrom?.includes(String(input.senderId))) {
-    return 'Nicht verbunden. Sende eine Nachricht, um einen Verbindungscode zu erhalten.';
-  }
-
-  const username = input.username ? `@${String(input.username).replace(/^@/u, '')}` : 'verbundener Nutzer';
-  const tui = input.tuiFresh
-    ? `verbunden${Number.isInteger(input.tuiPid) ? ` (PID ${input.tuiPid}${input.consoleStatus?.processStartedAt
-      ? `, ${formatDuration((Date.parse(input.capturedAt) - Date.parse(input.consoleStatus.processStartedAt)) / 1000)}`
-      : ''})` : ''}`
-    : 'nicht verbunden';
-  const delivery = input.deliveryTarget === 'tui'
-    ? 'Konsolen-Warteschlange'
-    : 'Brücke ohne Konsole';
-  const heartbeatAge = formatAge(input.tuiHeartbeatAt, input.capturedAt);
-  const checkpointAge = formatAge(input.queueCheckpointAt, input.capturedAt);
-  const workLines = input.consoleStatus === undefined
-    ? ['Arbeitsstatus: nicht verfügbar']
-    : input.consoleStatus.turnActive
-      ? [
-          `Arbeitsstatus: aktiv, Schritt ${input.consoleStatus.step}`,
-          ...(input.consoleStatus.activeTask === undefined ? [] : [`Aktive Aufgabe: ${input.consoleStatus.activeTask}`]),
-          ...(formatAge(input.consoleStatus.turnStartedAt, input.capturedAt) === undefined
-            ? [] : [`Zugbeginn: ${formatAge(input.consoleStatus.turnStartedAt, input.capturedAt)}`]),
-          ...(formatAge(input.consoleStatus.lastProgressAt, input.capturedAt) === undefined
-            ? [] : [`Letzter Fortschritt: ${formatAge(input.consoleStatus.lastProgressAt, input.capturedAt)}`]),
-          ...(input.consoleStatus.lastToolName === undefined
-            ? [] : [`Letztes Werkzeug: ${input.consoleStatus.lastToolName}`]),
-          ...(input.consoleStatus.failedRepetitions === undefined
-            ? [] : [`Wiederholte Fehler: ${input.consoleStatus.failedRepetitions}`]),
-        ]
-      : ['Arbeitsstatus: Leerlauf'];
-  return [
-    `BLUN-Fernstatus für ${username}`,
-    `Rechner: ${input.machineName || 'unbekannt'}`,
-    `Version: ${resolveVersionDisplay(input)}`,
-    `Brücke: aktiv (PID ${input.bridgePid}, ${formatDuration(input.bridgeUptimeSeconds)})`,
-    `Konsole: ${tui}`,
-    `Zustellung: ${delivery}`,
-    `Warteschlange: ${input.queueUnreadBytes === undefined ? 'unbekannt' : `${formatBytes(input.queueUnreadBytes)} ungelesen`} (${formatBytes(input.queueBytes)} gesamt)`,
-    ...(heartbeatAge === undefined ? [] : [`Konsolen-Herzschlag: ${heartbeatAge}`]),
-    ...(checkpointAge === undefined ? [] : [`Warteschlangen-Fortschritt: ${checkpointAge}`]),
-    ...workLines,
-    `Gemessen: ${input.capturedAt}`,
-  ].join('\n');
-}
-
-module.exports = {
-  buildTelegramRemoteStatus,
-  formatBytes,
-  formatDuration,
-  resolveTelegramQueueSnapshot,
-  resolveTelegramRemoteVersion,
-};

package/bin/telegram-session-queue-runtime.mjs

@@ -1,306 +0,0 @@
-// ../king-console-i18n-20260813/apps/blun-king/src/tui/controllers/telegram-session-queue-delivery.ts
-import { closeSync as closeSync2, fstatSync, openSync as openSync2, readSync } from "node:fs";
-import { join } from "node:path";
-
-// ../king-console-i18n-20260813/apps/blun-king/src/tui/constant/telegram-session-queue.ts
-var SESSION_QUEUE_READ_BYTES = 65536;
-var SESSION_QUEUE_MAX_IN_FLIGHT = 16;
-
-// ../king-console-i18n-20260813/apps/blun-king/src/tui/utils/channel-injection.ts
-function parseChannelEnvelope(line) {
-  const trimmed = line.trim();
-  if (trimmed.length === 0) return void 0;
-  let parsed;
-  try {
-    parsed = JSON.parse(trimmed);
-  } catch {
-    return void 0;
-  }
-  if (typeof parsed !== "object" || parsed === null) return void 0;
-  const record = parsed;
-  if (typeof record["text"] !== "string" || typeof record["tag"] !== "string") return void 0;
-  const meta = record["meta"];
-  if (typeof meta !== "object" || meta === null) return void 0;
-  if (typeof meta["chat_id"] !== "string") return void 0;
-  return record;
-}
-
-// ../king-console-i18n-20260813/apps/blun-king/src/tui/controllers/telegram-session-queue.ts
-function requireValid(condition) {
-  if (!condition) throw new Error("Invalid Telegram session queue state or transition");
-}
-function isRecord(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function isId(value) {
-  return typeof value === "string" && value.trim() === value && value.length > 0 && value.length <= 256 && !/[\u0000-\u001F\u007F]/u.test(value);
-}
-function isOffset(value) {
-  return typeof value === "number" && Number.isSafeInteger(value) && value >= 0;
-}
-function readSpan(value) {
-  requireValid(isRecord(value));
-  const { start, end } = value;
-  requireValid(isOffset(start) && isOffset(end) && start < end);
-  return { start, end };
-}
-function ownsRange(state, sessionId, span) {
-  return state.spans.some((owned) => owned.sessionId === sessionId && owned.start <= span.start && owned.end >= span.end);
-}
-function parseSessionQueue(value) {
-  requireValid(isRecord(value));
-  const { version, fileId, frontier, activeSessionId, sessions, spans, acknowledged } = value;
-  requireValid(version === 1 && isId(fileId) && isOffset(frontier) && isId(activeSessionId));
-  requireValid(Array.isArray(sessions) && sessions.every(isId));
-  const known = new Set(sessions);
-  requireValid(known.size === sessions.length && known.has(activeSessionId));
-  requireValid(Array.isArray(spans) && Array.isArray(acknowledged));
-  const owned = spans.map((raw) => {
-    const span = readSpan(raw);
-    requireValid(isRecord(raw));
-    const sessionId = raw["sessionId"];
-    requireValid(sessionId === null || isId(sessionId) && known.has(sessionId));
-    return { ...span, sessionId };
-  });
-  for (let i = 0; i < owned.length; i += 1) {
-    const span = owned[i];
-    const previous = owned[i - 1];
-    requireValid(span.end <= frontier && (previous === void 0 || previous.end === span.start));
-    requireValid(previous === void 0 || previous.sessionId !== span.sessionId);
-  }
-  requireValid(owned.length === 0 || owned.at(-1).end === frontier);
-  const confirmed = acknowledged.map(readSpan);
-  const state = {
-    version,
-    fileId,
-    frontier,
-    activeSessionId,
-    sessions: [...sessions],
-    spans: owned,
-    acknowledged: confirmed
-  };
-  for (let i = 0; i < confirmed.length; i += 1) {
-    const span = confirmed[i];
-    const previous = confirmed[i - 1];
-    requireValid(previous === void 0 || previous.end < span.start);
-    requireValid(owned.length > 0 && span.start >= owned[0].start && span.end <= frontier);
-    requireValid(!owned.some((part) => part.sessionId === null && part.start < span.end && part.end > span.start));
-  }
-  return state;
-}
-function createSessionQueue(input) {
-  requireValid(input.mode === "new" || input.mode === "resume");
-  requireValid(isOffset(input.checkpoint) && isOffset(input.frontier) && input.checkpoint <= input.frontier);
-  return parseSessionQueue({
-    version: 1,
-    fileId: input.fileId,
-    frontier: input.frontier,
-    activeSessionId: input.sessionId,
-    sessions: [input.sessionId],
-    spans: input.checkpoint === input.frontier ? [] : [{
-      start: input.checkpoint,
-      end: input.frontier,
-      sessionId: input.mode === "resume" ? input.sessionId : null
-    }],
-    acknowledged: []
-  });
-}
-function observeSessionQueue(state, position) {
-  const next = parseSessionQueue(state);
-  requireValid(position.fileId === next.fileId && isOffset(position.frontier) && position.frontier >= next.frontier);
-  if (position.frontier === next.frontier) return next;
-  const last = next.spans.at(-1);
-  if (last?.sessionId === next.activeSessionId) last.end = position.frontier;
-  else next.spans.push({ start: next.frontier, end: position.frontier, sessionId: next.activeSessionId });
-  next.frontier = position.frontier;
-  return next;
-}
-function bindSessionQueue(state, binding) {
-  requireValid(isId(binding.sessionId) && (binding.mode === "new" || binding.mode === "resume"));
-  const next = observeSessionQueue(state, binding);
-  requireValid(binding.mode !== "new" || !next.sessions.includes(binding.sessionId));
-  if (!next.sessions.includes(binding.sessionId)) next.sessions.push(binding.sessionId);
-  next.activeSessionId = binding.sessionId;
-  return next;
-}
-function pendingSessionQueue(state, sessionId) {
-  const validated = parseSessionQueue(state);
-  requireValid(isId(sessionId));
-  const pending = [];
-  for (const span of validated.spans) {
-    if (span.sessionId !== sessionId) continue;
-    let cursor = span.start;
-    for (const confirmed of validated.acknowledged) {
-      if (confirmed.end <= cursor) continue;
-      if (confirmed.start >= span.end) break;
-      if (confirmed.start > cursor) pending.push({ fileId: validated.fileId, start: cursor, end: confirmed.start });
-      cursor = Math.min(span.end, Math.max(cursor, confirmed.end));
-    }
-    if (cursor < span.end) pending.push({ fileId: validated.fileId, start: cursor, end: span.end });
-  }
-  return pending;
-}
-function acknowledgeSessionQueue(state, sessionId, range) {
-  const next = parseSessionQueue(state);
-  const span = readSpan(range);
-  requireValid(range.fileId === next.fileId && isId(sessionId) && ownsRange(next, sessionId, span));
-  const sorted = [...next.acknowledged, span].toSorted((a, b) => a.start - b.start);
-  next.acknowledged = [];
-  for (const item of sorted) {
-    const previous = next.acknowledged.at(-1);
-    if (previous !== void 0 && item.start <= previous.end) previous.end = Math.max(previous.end, item.end);
-    else next.acknowledged.push({ ...item });
-  }
-  return next;
-}
-
-// ../king-console-i18n-20260813/apps/blun-king/src/tui/controllers/telegram-session-queue-store.ts
-import { randomUUID } from "node:crypto";
-import { closeSync, fsyncSync, openSync, readFileSync, renameSync, rmSync, writeFileSync } from "node:fs";
-function readSessionQueue(path) {
-  try {
-    return parseSessionQueue(JSON.parse(readFileSync(path, "utf8")));
-  } catch (error) {
-    if (error.code === "ENOENT") return void 0;
-    throw error;
-  }
-}
-function writeSessionQueue(path, state) {
-  const bytes = `${JSON.stringify(parseSessionQueue(state))}
-`;
-  const temporary = `${path}.${randomUUID()}.tmp`;
-  const fd = openSync(temporary, "wx", 384);
-  try {
-    try {
-      writeFileSync(fd, bytes, "utf8");
-      fsyncSync(fd);
-    } finally {
-      closeSync(fd);
-    }
-    renameSync(temporary, path);
-  } finally {
-    rmSync(temporary, { force: true });
-  }
-}
-
-// ../king-console-i18n-20260813/apps/blun-king/src/tui/controllers/telegram-session-queue-delivery.ts
-function captureSessionQueueBoundary(queueFile) {
-  let fd;
-  try {
-    fd = openSync2(queueFile, "r");
-  } catch (error) {
-    if (error.code === "ENOENT") return void 0;
-    throw error;
-  }
-  try {
-    const stats = fstatSync(fd);
-    const fileId = `${stats.dev}:${stats.ino}:${stats.birthtimeMs}`;
-    let end = stats.size;
-    const buffer = Buffer.alloc(SESSION_QUEUE_READ_BYTES);
-    while (end > 0) {
-      const start = Math.max(0, end - buffer.length);
-      const length = readSync(fd, buffer, 0, end - start, start);
-      const newline = buffer.subarray(0, length).lastIndexOf(10);
-      if (newline >= 0) return { fileId, frontier: start + newline + 1 };
-      end = start;
-    }
-    return { fileId, frontier: 0 };
-  } finally {
-    closeSync2(fd);
-  }
-}
-function* readLines(queueFile, range) {
-  const fd = openSync2(queueFile, "r");
-  try {
-    const stats = fstatSync(fd);
-    if (`${stats.dev}:${stats.ino}:${stats.birthtimeMs}` !== range.fileId || stats.size < range.end) {
-      throw new Error("Telegram queue changed during delivery");
-    }
-    let cursor = range.start;
-    let lineStart = range.start;
-    let remainder = Buffer.alloc(0);
-    while (cursor < range.end) {
-      const buffer = Buffer.alloc(Math.min(SESSION_QUEUE_READ_BYTES, range.end - cursor));
-      const read = readSync(fd, buffer, 0, buffer.length, cursor);
-      if (read === 0) throw new Error("Telegram queue changed during delivery");
-      cursor += read;
-      const combined = Buffer.concat([remainder, buffer.subarray(0, read)]);
-      let from = 0;
-      for (let index = 0; index < combined.length; index += 1) {
-        if (combined[index] !== 10) continue;
-        const end = lineStart + index - from + 1;
-        yield { text: combined.subarray(from, index).toString("utf8"), range: { fileId: range.fileId, start: lineStart, end } };
-        lineStart = end;
-        from = index + 1;
-      }
-      remainder = combined.subarray(from);
-    }
-    if (remainder.length > 0) throw new Error("Telegram queue range is not a complete record");
-  } finally {
-    closeSync2(fd);
-  }
-}
-var SessionQueueDelivery = class {
-  constructor(dir, host) {
-    this.host = host;
-    this.queueFile = join(dir, "inbound-queue.jsonl");
-    this.stateFile = join(dir, "session-queue.json");
-  }
-  host;
-  boundSessionId;
-  inFlight = /* @__PURE__ */ new Set();
-  queueFile;
-  stateFile;
-  poll(scope, deliver = true) {
-    if (scope === void 0 || !this.host.ownsChannel()) return;
-    const position = captureSessionQueueBoundary(this.queueFile);
-    if (position === void 0) return;
-    let state = readSessionQueue(this.stateFile);
-    const before = state === void 0 ? void 0 : JSON.stringify(state);
-    const rebind = this.boundSessionId !== scope.sessionId || state?.activeSessionId !== scope.sessionId;
-    if (rebind && state?.activeSessionId !== scope.sessionId) {
-      const boundary = this.boundSessionId === scope.sessionId ? position : scope.boundary === "absent" ? { fileId: position.fileId, frontier: 0 } : scope.boundary ?? position;
-      if (boundary.fileId !== position.fileId || boundary.frontier > position.frontier) {
-        throw new Error("Telegram session queue boundary is stale");
-      }
-      state = state === void 0 ? createSessionQueue({ ...boundary, checkpoint: Math.min(this.host.legacyCheckpoint(), boundary.frontier), sessionId: scope.sessionId, mode: scope.mode }) : bindSessionQueue(state, {
-        fileId: position.fileId,
-        frontier: Math.max(state.frontier, boundary.frontier),
-        sessionId: scope.sessionId,
-        mode: state.sessions.includes(scope.sessionId) ? "resume" : scope.mode
-      });
-    }
-    if (state === void 0) throw new Error("Telegram session queue checkpoint is missing");
-    state = observeSessionQueue(state, position);
-    if (JSON.stringify(state) !== before) writeSessionQueue(this.stateFile, state);
-    if (rebind) this.inFlight.clear();
-    this.boundSessionId = scope.sessionId;
-    if (!deliver) return;
-    if (this.inFlight.size >= SESSION_QUEUE_MAX_IN_FLIGHT) return;
-    let delivered = 0;
-    for (const pending of pendingSessionQueue(state, scope.sessionId)) {
-      for (const line of readLines(this.queueFile, pending)) {
-        if (!this.host.ownsChannel() || this.host.currentSessionId() !== scope.sessionId) return;
-        const key = `${line.range.fileId}:${line.range.start}:${line.range.end}`;
-        if (this.inFlight.has(key)) continue;
-        const acknowledge = () => {
-          if (!this.host.ownsChannel()) return;
-          const current = readSessionQueue(this.stateFile);
-          if (current === void 0) throw new Error("Telegram session queue checkpoint is missing");
-          writeSessionQueue(this.stateFile, acknowledgeSessionQueue(current, scope.sessionId, line.range));
-          this.inFlight.delete(key);
-        };
-        this.inFlight.add(key);
-        const envelope = parseChannelEnvelope(line.text);
-        if (envelope === void 0) acknowledge();
-        else this.host.inject(envelope, acknowledge);
-        delivered += 1;
-        if (delivered >= SESSION_QUEUE_MAX_IN_FLIGHT || this.inFlight.size >= SESSION_QUEUE_MAX_IN_FLIGHT) return;
-      }
-    }
-  }
-};
-export {
-  SessionQueueDelivery,
-  captureSessionQueueBoundary
-};

package/bin/telegram-text-chunk-policy.cjs

@@ -1,63 +0,0 @@
-'use strict';
-
-const TELEGRAM_TEXT_LIMIT = 4096;
-
-function preferredCut(text, start, hardEnd) {
-  const minimum = start + Math.floor((hardEnd - start) / 2);
-  const boundaries = [
-    ['\n\n', 2],
-    ['\n', 1],
-    [' ', 1],
-  ];
-  for (const [boundary, width] of boundaries) {
-    const index = text.lastIndexOf(boundary, hardEnd - 1);
-    if (index >= minimum) return index + width;
-  }
-  return hardEnd;
-}
-
-function preserveSurrogatePair(text, start, end) {
-  if (end <= start || end >= text.length) return end;
-  const before = text.charCodeAt(end - 1);
-  const after = text.charCodeAt(end);
-  const splitsPair = before >= 0xD800 && before <= 0xDBFF && after >= 0xDC00 && after <= 0xDFFF;
-  return splitsPair && end - 1 > start ? end - 1 : end;
-}
-
-function splitTelegramText(value, limit = TELEGRAM_TEXT_LIMIT) {
-  const text = typeof value === 'string' ? value : String(value ?? '');
-  if (text.length === 0) return [];
-  if (!Number.isSafeInteger(limit) || limit <= 0) {
-    throw new TypeError('Telegram text chunk limit must be a positive safe integer');
-  }
-
-  const chunks = [];
-  let start = 0;
-  while (start < text.length) {
-    const hardEnd = Math.min(text.length, start + limit);
-    let end = hardEnd < text.length ? preferredCut(text, start, hardEnd) : hardEnd;
-    end = preserveSurrogatePair(text, start, end);
-    if (end <= start) end = hardEnd;
-    chunks.push(text.slice(start, end));
-    start = end;
-  }
-  return chunks;
-}
-
-async function sendTelegramTextChunks(value, sendChunk, limit = TELEGRAM_TEXT_LIMIT) {
-  if (typeof sendChunk !== 'function') {
-    throw new TypeError('Telegram chunk sender must be a function');
-  }
-  const chunks = splitTelegramText(value, limit);
-  const results = [];
-  for (let index = 0; index < chunks.length; index += 1) {
-    results.push(await sendChunk(chunks[index], index, chunks.length));
-  }
-  return { chunks, results };
-}
-
-module.exports = {
-  TELEGRAM_TEXT_LIMIT,
-  sendTelegramTextChunks,
-  splitTelegramText,
-};

package/bin/telegram-truncated-reply-policy.cjs

@@ -1,37 +0,0 @@
-'use strict';
-
-const MAX_TRUNCATED_REPLY_RETRIES = 3;
-
-const TRUNCATED_REPLY_CONTINUATION_PROMPT = [
-  'The previous channel reply hit the model output limit and was not delivered.',
-  'Produce one complete, concise final answer now from the preserved context.',
-  'Include every result the user needs, omit internal reasoning, do not mention this recovery,',
-  'and keep the visible answer under 3000 characters.',
-  'Do not call tools unless a missing fact must be verified.',
-].join(' ');
-
-function channelReplyRecoveryDecision({
-  hasPendingReply = false,
-  lastStepFinishReason,
-  retryCount = 0,
-  turnReason,
-} = {}) {
-  if (!hasPendingReply || turnReason !== 'completed' || lastStepFinishReason !== 'max_tokens') {
-    return { kind: 'fallback' };
-  }
-  const boundedRetryCount = Number.isSafeInteger(retryCount) && retryCount > 0
-    ? retryCount
-    : 0;
-  if (boundedRetryCount >= MAX_TRUNCATED_REPLY_RETRIES) return { kind: 'exhausted' };
-  return {
-    kind: 'retry',
-    nextRetryCount: boundedRetryCount + 1,
-    prompt: TRUNCATED_REPLY_CONTINUATION_PROMPT,
-  };
-}
-
-module.exports = {
-  MAX_TRUNCATED_REPLY_RETRIES,
-  TRUNCATED_REPLY_CONTINUATION_PROMPT,
-  channelReplyRecoveryDecision,
-};

package/bin/telegram-urgent-policy.cjs

@@ -1,45 +0,0 @@
-'use strict';
-
-function isPrivateTelegramChat(chatId) {
-  return /^[1-9]\d*$/u.test(String(chatId ?? '').trim());
-}
-
-function telegramUrgentMessage(envelope) {
-  if (!isPrivateTelegramChat(envelope?.meta?.chat_id)) return undefined;
-  const match = /^\/urgent(?:@[A-Za-z0-9_]+)?(?:\s+([\s\S]*))?$/iu.exec(
-    String(envelope?.text ?? '').trim(),
-  );
-  const text = match?.[1]?.trim() ?? '';
-  if (text.length === 0) return undefined;
-  return { text, displayText: text };
-}
-
-function rewriteTelegramUrgentEnvelope(envelope, text) {
-  const originalText = String(envelope?.text ?? '');
-  const originalTag = String(envelope?.tag ?? '');
-  if (originalText.length === 0 || !originalTag.includes(originalText)) return undefined;
-  const tagWithText = originalTag.replace(originalText, text);
-  const tag = tagWithText.replace(
-    /<channel\b(?![^>]*\bpriority=)/u,
-    '<channel priority="urgent"',
-  );
-  if (tag === tagWithText) return undefined;
-  return {
-    ...envelope,
-    text,
-    tag,
-    meta: { ...envelope.meta, priority: 'urgent' },
-  };
-}
-
-function enqueueTelegramUrgent(queue, item) {
-  const firstNormal = queue.findIndex((queued) => queued.channelUrgent !== true);
-  queue.splice(firstNormal < 0 ? queue.length : firstNormal, 0, item);
-}
-
-module.exports = {
-  enqueueTelegramUrgent,
-  isPrivateTelegramChat,
-  rewriteTelegramUrgentEnvelope,
-  telegramUrgentMessage,
-};