blun-king-cli 9.1.569 → 9.1.571

package/CHANGELOG.md

@@ -0,0 +1,55 @@
+# Changelog
+
+## 9.1.571
+
+- Bind Telegram queue ranges to their owning session. A new session no longer automatically consumes work left pending by an older session; resuming a known session restores only its own pending ranges.
+- Pause channel intake across session selection, creation and switching. Preserve messages arriving after the chosen boundary, local editor follow-ups, and late acknowledgements for their original owner.
+- Keep queue ownership and out-of-order acknowledgements durable across reattachment and lease handover. Reject corrupt or replaced queue state instead of silently replaying old input.
+- Preserve the original inbox and session history. Legacy pending ranges without an identifiable session are parked rather than assigned to an unrelated new session. Automatic recovery of those unowned legacy ranges is not included.
+
+This change does not diagnose or repair every model timeout, compaction stall or cancelled turn. An explicit paused-work state remains a pause. Older application versions do not understand the new session-queue checkpoint; downgrading is not a queue-migration mechanism.
+
+
+- Apply the group-chatter correction to both the Telegram plugin and the console's independent automatic reply fallback.
+- Suppress recognized acknowledgements and narrated silence even when they are longer than 200 characters. Preserve a message whenever it also contains an unrecognized or substantive clause.
+- Preserve short useful group warnings. Message length alone no longer suppresses context-only replies in the console fallback.
+- Explain that ordinary assistant text can be forwarded automatically. Group turns without a request or useful contribution should produce neither a reply tool call nor an assistant message announcing silence.
+- Preserve private replies, group access settings, mention routing, media delivery, and the existing managed-plugin installation mechanism.
+
+This is a conservative German/English delivery guard plus prompt guidance, not a guarantee that every model understands every group conversation. A new process must load the updated package; running sessions are not restarted by this release.
+
+Packages pinned to the old internal update channel still require an explicit npm installation with King closed. Windows EBUSY remains a separate installation-lock problem; do not delete the package or stop unrelated processes on assumption.
+
+All other changes from 9.1.570 remain included. This release does not activate the hosted web-search route or change AgentSpine, billing, authentication, or customer configuration.
+
+## 9.1.570
+
+### Fixed
+
+- Give each new prompt delivery a distinct hook correlation ID. Hooks for the same delivery retain the same ID; explicitly supplied IDs are preserved.
+- Pass session-specific runtime environment values to hook subprocesses and MCP connections, including reconnects, without rewriting stored plugin configuration.
+- Preserve native tool-result correlation across turns, including failed tools and duplicate calls.
+- Match canonically equivalent Unicode research queries without conflating different characters. Stored sources, dates, versions and project boundaries are preserved.
+- Keep `king --help` and `king --version` from changing Windows crash-dump registry settings.
+
+### Added
+
+- Support negotiated partial web-search results with a visible source-failure notice. Empty or incompatible partial responses remain explicit errors. This client change does not activate or guarantee a hosted search service.
+- Add the default-off `BLUN_EXPERIMENTAL_AGENT_SPINE_TIMELINE` transport. When explicitly enabled, it passes the actual persisted session-record path and protocol to the selected AgentSpine plugin, with a separate capability per session and a new capability after resume. This is transport support, not proof of recall or authorization by the receiving plugin.
+
+### Preserved
+
+- Includes the public 9.1.569 Telegram group mention routing, startup, permission persistence, research collection and crawler changes.
+- The bundled AgentSpine implementation is unchanged from public 9.1.569. No Mnemo dependency is introduced.
+- User profiles, permissions, conversations and plugin settings are not migrated or reset by this release.
+
+### Updating
+
+- Public-channel installations use `king update`.
+- Old packages explicitly pinned to the internal update channel do not discover public releases. Close the relevant King sessions, then migrate once with `npm install -g blun-king-cli@9.1.570`.
+- A Windows `EBUSY` rename failure means the installation did not complete. Identify the process holding the package before retrying; do not delete the package or terminate unrelated Node processes.
+
+## 9.1.569
+
+- Cumulative public release including Telegram group mention routing, startup and permission fixes, research collection, and crawler tooling.
+- Published artifacts are immutable. Later changes ship under a new version.

package/bin/core-bootstrap.js

@@ -12,7 +12,8 @@ const CORE_LOADED_MESSAGE = 'blun-core-bootstrap-loaded';
 async function runCoreBootstrap() {
   const packageRoot = path.resolve(__dirname, '..');
   const mainPath = path.join(packageRoot, 'blun.mjs');
-  installWindowsNodeCrashDump({ homeDir: process.env.BLUN_HOME });
+  const informational = process.argv.slice(2).some(arg => ['-h', '--help', '-V', '--version'].includes(arg));
+  if (!informational) installWindowsNodeCrashDump({ homeDir: process.env.BLUN_HOME });
   const leaseResult = await acquireSharedRuntimeLease({ packageRoot });
   if (!leaseResult.acquired) throw new Error('RUNTIME_PROTECTION_UNAVAILABLE');
 

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

@@ -0,0 +1,306 @@
+// ../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
+};