blun-king-cli 9.1.462 → 9.1.464

package/bin/agent-api-runtime.mjs

@@ -0,0 +1,252 @@
+import { createHash } from 'node:crypto';
+import { createRequire } from 'node:module';
+
+const require = createRequire(import.meta.url);
+const { createAgentApiToolBroker } = require('./agent-api-tool-broker.cjs');
+
+const CLIENT_TOOL_NAME_PATTERN = /^[A-Za-z0-9_-]{1,64}$/u;
+const INTERNAL_TOOL_PREFIX = 'client__';
+const NO_CLIENT_TOOLS_PREFIX = '__blun_agent_api_no_client_tools__';
+
+class AgentApiRuntimeError extends Error {
+  constructor(code, message) {
+    super(message);
+    this.name = 'AgentApiRuntimeError';
+    this.code = code;
+  }
+}
+
+function runtimeError(code, message) {
+  return new AgentApiRuntimeError(code, message);
+}
+
+function requireId(value, label) {
+  if (typeof value !== 'string' || value.trim().length === 0) {
+    throw runtimeError('AGENT_API_INVALID_SCOPE', `${label} must be a non-empty string`);
+  }
+  return value.trim();
+}
+
+function cloneStructured(value, label) {
+  try {
+    return structuredClone(value);
+  } catch {
+    throw runtimeError(
+      'AGENT_API_INVALID_TOOL_DEFINITION',
+      `${label} must be structured-cloneable`,
+    );
+  }
+}
+
+function normalizeParameters(value, name) {
+  if (value === undefined) {
+    return { type: 'object', properties: {} };
+  }
+  if (value === null || typeof value !== 'object' || Array.isArray(value)) {
+    throw runtimeError(
+      'AGENT_API_INVALID_TOOL_DEFINITION',
+      `tool "${name}" parameters must be an object`,
+    );
+  }
+  return cloneStructured(value, `tool "${name}" parameters`);
+}
+
+function normalizeClientToolDefinitions(tools) {
+  if (!Array.isArray(tools)) {
+    throw runtimeError('AGENT_API_INVALID_TOOLS', 'tools must be an array');
+  }
+
+  const names = new Set();
+  return tools.map((tool, index) => {
+    if (tool === null || typeof tool !== 'object' || Array.isArray(tool)
+      || tool.type !== 'function'
+      || tool.function === null
+      || typeof tool.function !== 'object'
+      || Array.isArray(tool.function)) {
+      throw runtimeError(
+        'AGENT_API_INVALID_TOOL_DEFINITION',
+        `tools[${index}] must be an OpenAI function tool`,
+      );
+    }
+
+    const name = tool.function.name;
+    if (typeof name !== 'string' || !CLIENT_TOOL_NAME_PATTERN.test(name)) {
+      throw runtimeError(
+        'AGENT_API_INVALID_TOOL_DEFINITION',
+        `tools[${index}].function.name must match ${CLIENT_TOOL_NAME_PATTERN}`,
+      );
+    }
+    if (names.has(name)) {
+      throw runtimeError(
+        'AGENT_API_DUPLICATE_TOOL_NAME',
+        `tool name "${name}" is declared more than once`,
+      );
+    }
+    names.add(name);
+
+    const description = tool.function.description;
+    if (description !== undefined && typeof description !== 'string') {
+      throw runtimeError(
+        'AGENT_API_INVALID_TOOL_DEFINITION',
+        `tool "${name}" description must be a string`,
+      );
+    }
+
+    return Object.freeze({
+      name,
+      description: description ?? '',
+      parameters: normalizeParameters(tool.function.parameters, name),
+    });
+  });
+}
+
+function shortHash(value, length = 10) {
+  return createHash('sha256').update(value).digest('hex').slice(0, length);
+}
+
+function internalToolName(publicName, index) {
+  const ordinal = index.toString(36).padStart(2, '0');
+  const prefix = `${INTERNAL_TOOL_PREFIX}${ordinal}__`;
+  const suffix = `__${shortHash(publicName, 8)}`;
+  const available = 64 - prefix.length - suffix.length;
+  return `${prefix}${publicName.slice(0, available)}${suffix}`;
+}
+
+function noClientToolsSentinel(sessionId, requestId) {
+  return `${NO_CLIENT_TOOLS_PREFIX}${shortHash(`${sessionId}\0${requestId}`, 16)}`;
+}
+
+function validateSession(session) {
+  if (session === null || typeof session !== 'object') {
+    throw runtimeError('AGENT_API_INVALID_SESSION', 'session must be an SDK session');
+  }
+  const requiredMethods = [
+    'registerToolAndWait',
+    'unregisterToolAndWait',
+    'setAllowedTools',
+  ];
+  for (const method of requiredMethods) {
+    if (typeof session[method] !== 'function') {
+      throw runtimeError(
+        'AGENT_API_INVALID_SESSION',
+        `session.${method} must be a function`,
+      );
+    }
+  }
+  return requireId(session.id, 'session.id');
+}
+
+async function unregisterTools(session, names) {
+  let firstError;
+  for (const name of [...names].reverse()) {
+    try {
+      await session.unregisterToolAndWait(name);
+    } catch (error) {
+      firstError ??= error;
+    }
+  }
+  if (firstError !== undefined) throw firstError;
+}
+
+function createAgentApiRuntime(options = {}) {
+  const broker = options.broker ?? createAgentApiToolBroker(options.brokerOptions);
+
+  async function bindClientTools(input) {
+    if (input === null || typeof input !== 'object') {
+      throw runtimeError('AGENT_API_INVALID_REQUEST', 'binding input must be an object');
+    }
+
+    const sessionId = validateSession(input.session);
+    const requestId = requireId(input.requestId, 'requestId');
+    const tools = normalizeClientToolDefinitions(input.tools ?? []);
+    const mappings = tools.map((tool, index) => Object.freeze({
+      ...tool,
+      internalName: internalToolName(tool.name, index),
+    }));
+    const registeredNames = [];
+
+    broker.beginRequest({
+      sessionId,
+      requestId,
+      toolNames: mappings.map((tool) => tool.name),
+    });
+
+    try {
+      for (const tool of mappings) {
+        await input.session.registerToolAndWait(
+          tool.internalName,
+          tool.description,
+          tool.parameters,
+          (request) => broker.handleToolCall({
+            sessionId,
+            turnId: request.turnId,
+            toolCallId: request.toolCallId,
+            toolName: tool.name,
+            args: request.args,
+          }),
+        );
+        registeredNames.push(tool.internalName);
+      }
+
+      await input.session.setAllowedTools(
+        registeredNames.length > 0
+          ? registeredNames
+          : [noClientToolsSentinel(sessionId, requestId)],
+      );
+    } catch (error) {
+      broker.abortRequest({
+        sessionId,
+        requestId,
+        reason: 'Agent API SDK binding failed',
+      });
+      try {
+        await unregisterTools(input.session, registeredNames);
+      } catch {
+        // Preserve the binding error; cleanup was best-effort and all handlers are fail-closed.
+      }
+      throw error;
+    }
+
+    let closed = false;
+    function ensureOpen() {
+      if (closed) {
+        throw runtimeError('AGENT_API_BINDING_CLOSED', 'Agent API SDK binding is closed');
+      }
+    }
+
+    return Object.freeze({
+      sessionId,
+      requestId,
+      nextToolCall() {
+        ensureOpen();
+        return broker.nextToolCall({ sessionId, requestId });
+      },
+      submitToolResult(result) {
+        ensureOpen();
+        return broker.submitToolResult({ sessionId, requestId, ...result });
+      },
+      async finish() {
+        ensureOpen();
+        broker.finishRequest({ sessionId, requestId });
+        closed = true;
+        await unregisterTools(input.session, registeredNames);
+      },
+      async abort(reason = 'Agent API request aborted') {
+        ensureOpen();
+        broker.abortRequest({ sessionId, requestId, reason });
+        closed = true;
+        await unregisterTools(input.session, registeredNames);
+      },
+    });
+  }
+
+  return Object.freeze({ bindClientTools });
+}
+
+export {
+  AgentApiRuntimeError,
+  CLIENT_TOOL_NAME_PATTERN,
+  NO_CLIENT_TOOLS_PREFIX,
+  createAgentApiRuntime,
+  normalizeClientToolDefinitions,
+};

package/bin/agent-api-tool-broker.cjs

@@ -0,0 +1,248 @@
+'use strict';
+
+const DEFAULT_MAX_PENDING_TOOL_CALLS = 32;
+
+class AgentApiToolBrokerError extends Error {
+  constructor(code, message) {
+    super(message);
+    this.name = 'AgentApiToolBrokerError';
+    this.code = code;
+  }
+}
+
+function brokerError(code, message) {
+  return new AgentApiToolBrokerError(code, message);
+}
+
+function requireId(value, label) {
+  if (typeof value !== 'string' || value.trim().length === 0) {
+    throw brokerError('AGENT_API_INVALID_SCOPE', `${label} must be a non-empty string`);
+  }
+  return value.trim();
+}
+
+function normalizeToolNames(value) {
+  if (!Array.isArray(value)) {
+    throw brokerError('AGENT_API_INVALID_TOOLS', 'toolNames must be an array');
+  }
+  const names = value.map((name) => requireId(name, 'tool name'));
+  if (new Set(names).size !== names.length) {
+    throw brokerError('AGENT_API_INVALID_TOOLS', 'toolNames must not contain duplicates');
+  }
+  return new Set(names);
+}
+
+function normalizeMaxPendingToolCalls(value) {
+  const normalized = value ?? DEFAULT_MAX_PENDING_TOOL_CALLS;
+  if (!Number.isSafeInteger(normalized) || normalized < 1) {
+    throw brokerError(
+      'AGENT_API_INVALID_LIMIT',
+      'maxPendingToolCalls must be a positive safe integer',
+    );
+  }
+  return normalized;
+}
+
+function normalizeToolResult(input) {
+  if (typeof input.output !== 'string') {
+    throw brokerError('AGENT_API_INVALID_TOOL_RESULT', 'tool result output must be a string');
+  }
+  if (input.isError !== undefined && typeof input.isError !== 'boolean') {
+    throw brokerError('AGENT_API_INVALID_TOOL_RESULT', 'tool result isError must be a boolean');
+  }
+  return {
+    output: input.output,
+    isError: input.isError === true,
+  };
+}
+
+function cloneArgs(value) {
+  try {
+    return structuredClone(value);
+  } catch {
+    throw brokerError('AGENT_API_INVALID_TOOL_ARGS', 'tool arguments must be structured-cloneable');
+  }
+}
+
+function createDeferred() {
+  let resolve;
+  let reject;
+  const promise = new Promise((resolvePromise, rejectPromise) => {
+    resolve = resolvePromise;
+    reject = rejectPromise;
+  });
+  return { promise, reject, resolve };
+}
+
+function createAgentApiToolBroker(options = {}) {
+  const maxPendingToolCalls = normalizeMaxPendingToolCalls(options.maxPendingToolCalls);
+  const activeRequests = new Map();
+
+  function requestForScope(input) {
+    const sessionId = requireId(input.sessionId, 'sessionId');
+    const requestId = requireId(input.requestId, 'requestId');
+    const request = activeRequests.get(sessionId);
+    if (request === undefined) {
+      throw brokerError('AGENT_API_REQUEST_NOT_ACTIVE', 'no active Agent API request for session');
+    }
+    if (request.requestId !== requestId) {
+      throw brokerError(
+        'AGENT_API_TOOL_RESULT_SCOPE_MISMATCH',
+        'Agent API request does not match the active session request',
+      );
+    }
+    return request;
+  }
+
+  function pendingToolCallCount() {
+    let count = 0;
+    for (const request of activeRequests.values()) count += request.pending.size;
+    return count;
+  }
+
+  function deliverEvent(request, event) {
+    const waiter = request.eventWaiters.shift();
+    if (waiter !== undefined) {
+      waiter.resolve(event);
+      return;
+    }
+    request.events.push(event);
+  }
+
+  function beginRequest(input) {
+    const sessionId = requireId(input.sessionId, 'sessionId');
+    const requestId = requireId(input.requestId, 'requestId');
+    if (activeRequests.has(sessionId)) {
+      throw brokerError(
+        'AGENT_API_SESSION_BUSY',
+        'session already has an active Agent API request',
+      );
+    }
+    const request = {
+      sessionId,
+      requestId,
+      toolNames: normalizeToolNames(input.toolNames),
+      seenToolCallIds: new Set(),
+      pending: new Map(),
+      events: [],
+      eventWaiters: [],
+    };
+    activeRequests.set(sessionId, request);
+    return { sessionId, requestId };
+  }
+
+  function handleToolCall(input) {
+    const sessionId = requireId(input.sessionId, 'sessionId');
+    const toolCallId = requireId(input.toolCallId, 'toolCallId');
+    const toolName = requireId(input.toolName, 'toolName');
+    const request = activeRequests.get(sessionId);
+    if (request === undefined) {
+      return Promise.reject(brokerError(
+        'AGENT_API_REQUEST_NOT_ACTIVE',
+        'no active Agent API request for SDK tool call',
+      ));
+    }
+    if (!request.toolNames.has(toolName)) {
+      return Promise.reject(brokerError(
+        'AGENT_API_TOOL_NOT_DECLARED',
+        `tool "${toolName}" was not declared by the API client`,
+      ));
+    }
+    if (request.seenToolCallIds.has(toolCallId)) {
+      return Promise.reject(brokerError(
+        'AGENT_API_TOOL_CALL_DUPLICATE',
+        `tool call "${toolCallId}" has already been accepted`,
+      ));
+    }
+    if (pendingToolCallCount() >= maxPendingToolCalls) {
+      return Promise.reject(brokerError(
+        'AGENT_API_TOOL_CALL_LIMIT',
+        'too many client tool calls are waiting for results',
+      ));
+    }
+
+    const deferred = createDeferred();
+    request.seenToolCallIds.add(toolCallId);
+    request.pending.set(toolCallId, deferred);
+    deliverEvent(request, Object.freeze({
+      type: 'client_tool_call',
+      sessionId,
+      requestId: request.requestId,
+      turnId: input.turnId,
+      toolCallId,
+      toolName,
+      args: cloneArgs(input.args),
+    }));
+    return deferred.promise;
+  }
+
+  function nextToolCall(input) {
+    const request = requestForScope(input);
+    const event = request.events.shift();
+    if (event !== undefined) return Promise.resolve(event);
+    const deferred = createDeferred();
+    request.eventWaiters.push(deferred);
+    return deferred.promise;
+  }
+
+  function submitToolResult(input) {
+    const request = requestForScope(input);
+    const toolCallId = requireId(input.toolCallId, 'toolCallId');
+    const pending = request.pending.get(toolCallId);
+    if (pending === undefined) {
+      throw brokerError(
+        'AGENT_API_TOOL_CALL_NOT_PENDING',
+        `tool call "${toolCallId}" is not waiting for a result`,
+      );
+    }
+    const result = normalizeToolResult(input);
+    request.pending.delete(toolCallId);
+    pending.resolve(result);
+    return true;
+  }
+
+  function abortRequest(input) {
+    const request = requestForScope(input);
+    const reason = typeof input.reason === 'string' && input.reason.trim().length > 0
+      ? input.reason.trim()
+      : 'request aborted';
+    const error = brokerError('AGENT_API_REQUEST_ABORTED', reason);
+    activeRequests.delete(request.sessionId);
+    request.events.length = 0;
+    for (const waiter of request.eventWaiters.splice(0)) waiter.reject(error);
+    for (const pending of request.pending.values()) pending.reject(error);
+    request.pending.clear();
+    return true;
+  }
+
+  function finishRequest(input) {
+    const request = requestForScope(input);
+    if (request.pending.size > 0) {
+      throw brokerError(
+        'AGENT_API_REQUEST_HAS_PENDING_TOOLS',
+        'cannot finish a request while client tool results are pending',
+      );
+    }
+    const error = brokerError('AGENT_API_REQUEST_FINISHED', 'Agent API request finished');
+    activeRequests.delete(request.sessionId);
+    request.events.length = 0;
+    for (const waiter of request.eventWaiters.splice(0)) waiter.reject(error);
+    return true;
+  }
+
+  return Object.freeze({
+    abortRequest,
+    beginRequest,
+    finishRequest,
+    handleToolCall,
+    nextToolCall,
+    pendingToolCallCount,
+    submitToolResult,
+  });
+}
+
+module.exports = {
+  AgentApiToolBrokerError,
+  DEFAULT_MAX_PENDING_TOOL_CALLS,
+  createAgentApiToolBroker,
+};

package/bin/profile-runtime.cjs

@@ -28,6 +28,8 @@ const LEGACY_PROFILE_ENTRIES = Object.freeze([
 const MIGRATION_MARKER = '.legacy-profile-migrated-v1';
 const SESSION_PATH_MIGRATION_MARKER = '.legacy-profile-session-paths-v2';
 const SESSION_PATH_BACKUP_DIR = '.legacy-profile-session-paths-v2-backup';
+const PERSONA_LANGUAGE_MIGRATION_MARKER = '.legacy-persona-language-v1';
+const PERSONA_LANGUAGE_BACKUP = '.legacy-persona-language-v1-backup.json';
 
 function normalizeProfileName(value) {
   const normalized = String(value || '').trim().toLowerCase();
@@ -134,6 +136,56 @@ function backupFile(source, target, fsImpl) {
   fsImpl.copyFileSync(source, target);
 }
 
+function readJsonObject(target, fsImpl) {
+  if (!fsImpl.existsSync(target)) return null;
+  try {
+    const text = fsImpl.readFileSync(target, 'utf8');
+    const parsed = JSON.parse(text.charCodeAt(0) === 0xFEFF ? text.slice(1) : text);
+    return parsed && typeof parsed === 'object' && !Array.isArray(parsed) ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+
+function writeMarkerOnce(target, text, fsImpl) {
+  try {
+    fsImpl.writeFileSync(target, text, { encoding: 'utf8', flag: 'wx' });
+  } catch (error) {
+    if (error?.code !== 'EEXIST') throw error;
+  }
+}
+
+function repairDefaultProfilePersonaLanguage(sharedHome, fsImpl = fs) {
+  const paths = resolveProfilePaths(sharedHome, DEFAULT_PROFILE);
+  const marker = path.join(paths.home, PERSONA_LANGUAGE_MIGRATION_MARKER);
+  const profilePersonaPath = path.join(paths.home, 'persona.json');
+  const legacyPersonaPath = path.join(sharedHome, 'persona.json');
+  if (fsImpl.existsSync(marker) || !fsImpl.existsSync(profilePersonaPath)) return paths;
+
+  const profilePersona = readJsonObject(profilePersonaPath, fsImpl);
+  const legacyPersona = readJsonObject(legacyPersonaPath, fsImpl);
+  if (profilePersona === null || legacyPersona === null) return paths;
+
+  if (!Object.hasOwn(profilePersona, 'language')) {
+    const legacyLanguage = typeof legacyPersona.language === 'string'
+      ? legacyPersona.language.trim()
+      : '';
+    if (legacyLanguage) {
+      const original = fsImpl.readFileSync(profilePersonaPath, 'utf8');
+      backupFile(profilePersonaPath, path.join(paths.home, PERSONA_LANGUAGE_BACKUP), fsImpl);
+      replaceTextFileIfUnchanged(
+        profilePersonaPath,
+        original,
+        `${JSON.stringify({ ...profilePersona, language: legacyLanguage }, null, 2)}\n`,
+        fsImpl,
+      );
+    }
+  }
+
+  writeMarkerOnce(marker, 'legacy persona language repaired once\n', fsImpl);
+  return paths;
+}
+
 function rewriteSessionState(statePath, legacySessionDir, profileSessionDir, backupRoot, relativeSessionDir, fsImpl) {
   if (!fsImpl.existsSync(statePath)) return false;
   const original = fsImpl.readFileSync(statePath, 'utf8');
@@ -251,6 +303,7 @@ function seedDefaultProfileFromLegacy(sharedHome, fsImpl = fs) {
       if (error?.code !== 'EEXIST') throw error;
     }
   }
+  repairDefaultProfilePersonaLanguage(sharedHome, fsImpl);
   return repairDefaultProfileSessionPaths(sharedHome, fsImpl);
 }
 
@@ -258,6 +311,7 @@ module.exports = {
   DEFAULT_PROFILE,
   normalizeProfileName,
   parseProfileLaunchArgs,
+  repairDefaultProfilePersonaLanguage,
   repairDefaultProfileSessionPaths,
   resolveProfilePaths,
   seedDefaultProfileFromLegacy,

package/bin/session-replay-window-policy.cjs

@@ -0,0 +1,22 @@
+'use strict';
+
+function replayWindowStartIndex(records, activeTurnCount, startsTurn) {
+  if (
+    !Array.isArray(records)
+    || !Number.isSafeInteger(activeTurnCount)
+    || activeTurnCount <= 0
+    || typeof startsTurn !== 'function'
+  ) {
+    return 0;
+  }
+
+  let remainingTurns = activeTurnCount;
+  for (let index = records.length - 1; index >= 0; index -= 1) {
+    if (!startsTurn(records[index])) continue;
+    remainingTurns -= 1;
+    if (remainingTurns === 0) return index;
+  }
+  return 0;
+}
+
+module.exports = { replayWindowStartIndex };

package/bin/session-scrollback-archive.cjs

@@ -41,6 +41,7 @@ class SessionScrollbackArchive {
     this.loadedChunks = new Map();
     this.lineCount = 0;
     this.loadedExisting = false;
+    this.activeTurnCount = undefined;
 
     if (reset) {
       this.reset();
@@ -108,6 +109,21 @@ class SessionScrollbackArchive {
     return output;
   }
 
+  setActiveTurnCount(count) {
+    if (!isNonNegativeInteger(count)) return false;
+    if (this.activeTurnCount === count) return true;
+    const previous = this.activeTurnCount;
+    this.activeTurnCount = count;
+    try {
+      fs.mkdirSync(this.directory, { recursive: true });
+      this.writeIndex(this.chunks, this.lineCount);
+      return true;
+    } catch {
+      this.activeTurnCount = previous;
+      return false;
+    }
+  }
+
   reset() {
     try {
       fs.rmSync(this.directory, { recursive: true, force: true });
@@ -116,6 +132,7 @@ class SessionScrollbackArchive {
     this.loadedChunks.clear();
     this.lineCount = 0;
     this.loadedExisting = false;
+    this.activeTurnCount = undefined;
   }
 
   clear() {
@@ -165,6 +182,9 @@ class SessionScrollbackArchive {
 
       this.chunks = chunks;
       this.lineCount = parsed.totalLines;
+      this.activeTurnCount = isNonNegativeInteger(parsed.activeTurnCount)
+        ? parsed.activeTurnCount
+        : undefined;
       this.loadedExisting = true;
     } catch {}
   }
@@ -195,6 +215,9 @@ class SessionScrollbackArchive {
       schemaVersion: ARCHIVE_SCHEMA_VERSION,
       totalLines,
       chunks,
+      ...(isNonNegativeInteger(this.activeTurnCount)
+        ? { activeTurnCount: this.activeTurnCount }
+        : {}),
     }));
   }
 }

package/bin/subagent-parent-responsiveness.cjs

@@ -0,0 +1,19 @@
+'use strict';
+
+function resolveSubagentRunMode({ allowBackground, requested }) {
+  if (allowBackground !== true) {
+    return {
+      runInBackground: false,
+      forcedForParentResponsiveness: false,
+    };
+  }
+
+  return {
+    runInBackground: true,
+    forcedForParentResponsiveness: requested !== true,
+  };
+}
+
+module.exports = {
+  resolveSubagentRunMode,
+};

package/bin/telegram-addressed-focus.cjs

@@ -0,0 +1,45 @@
+'use strict';
+
+function createAddressedChannelFocusStore(options = {}) {
+  const maxItems = Math.max(1, Number(options.maxItems) || 3);
+  const onChange = typeof options.onChange === 'function' ? options.onChange : () => {};
+  let sequence = 0;
+  let items = [];
+
+  function snapshot() {
+    return items.map((item) => ({ ...item }));
+  }
+
+  function publish() {
+    onChange(snapshot());
+  }
+
+  return {
+    pin(input) {
+      const item = {
+        id: `channel-focus-${++sequence}`,
+        chatId: String(input.chatId),
+        origin: String(input.origin ?? ''),
+        text: String(input.text ?? '').trim(),
+      };
+      items = [...items, item].slice(-maxItems);
+      publish();
+      return item.id;
+    },
+
+    clearChat(chatId) {
+      const expected = String(chatId);
+      const next = items.filter((item) => item.chatId !== expected);
+      if (next.length === items.length) return false;
+      items = next;
+      publish();
+      return true;
+    },
+
+    snapshot,
+  };
+}
+
+module.exports = {
+  createAddressedChannelFocusStore,
+};

package/blun.mjs

@@ -13,6 +13,7 @@ import compactionModelPolicy from "./bin/compaction-model-policy.cjs";
 import agentResumeSnapshot from "./bin/agent-resume-snapshot.cjs";
 import sessionResumeCheckpoint from "./bin/session-resume-checkpoint.cjs";
 import sessionScrollbackArchive from "./bin/session-scrollback-archive.cjs";
+import sessionReplayWindowPolicy from "./bin/session-replay-window-policy.cjs";
 import crypto$1, { createHash, randomBytes, randomInt, randomUUID, timingSafeEqual } from "node:crypto";
 import * as fs$16 from "node:fs";
 import Kt, { accessSync, appendFileSync, chmodSync, closeSync, constants, copyFileSync, createReadStream, createWriteStream, existsSync, fsyncSync, linkSync, lstatSync, mkdirSync, openSync, promises, readFileSync, readSync, readdirSync, realpathSync, renameSync, rmSync, statSync, unlinkSync, writeFileSync, writeSync } from "node:fs";
@@ -50,6 +51,7 @@ const { resolveCompactionModelAlias } = compactionModelPolicy;
 const { createAgentResumeSnapshot, restoreAgentResumeSnapshot } = agentResumeSnapshot;
 const { loadResumeCheckpoint, writeResumeCheckpoint } = sessionResumeCheckpoint;
 const { SessionScrollbackArchive, sessionScrollbackArchiveDirectory } = sessionScrollbackArchive;
+const { replayWindowStartIndex } = sessionReplayWindowPolicy;
 import { EventEmitter as EventEmitter$1 } from "node:events";
 import { StringDecoder } from "node:string_decoder";
 import co from "node:assert";
@@ -28242,6 +28244,16 @@ function readPersona$1(env = process.env) {
 	const resolved = readProfilePersona(env);
 	return resolved.persona;
 }
+function defaultAnswerLanguageSystemBlock() {
+	return [
+		"## Default answer language — HARD RULE",
+		"",
+		"English is the initial language for new or unconfigured accounts, profiles, and sessions.",
+		"An explicit language saved in the account, profile, or current session overrides this default.",
+		"Detect the language of the user's latest conversational message and answer in that language, including languages such as Bengali.",
+		"Tool output does not change the conversational language. This rule overrides the generic # Language section when no explicit language is active."
+	].join("\n");
+}
 /**
 * Build the system-prompt block that teaches the agent its persona name, so it
 * warmly adopts the name the user gave it. Empty string when no name is set.
@@ -28408,6 +28420,7 @@ function buildTemplateVars(context, promptVars, tools) {
 	const now = context.now instanceof Date ? context.now.toISOString() : context.now ?? (/* @__PURE__ */ new Date()).toISOString();
 	const roleBase = context.roleAdditional ?? promptVars["ROLE_ADDITIONAL"] ?? promptVars["roleAdditional"] ?? "";
 	const roleAdditional = [
+		defaultAnswerLanguageSystemBlock(),
 		personaSystemBlock(),
 		soulSystemBlock(),
 		identitySystemBlock(),
@@ -252785,7 +252798,7 @@ var init_agent_background_disabled = __esmMin((() => {
 //#region ../../packages/agent-core/src/tools/builtin/collaboration/agent-background-enabled.md?raw
 var agent_background_enabled_default;
 var init_agent_background_enabled = __esmMin((() => {
-	agent_background_enabled_default = "When `run_in_background=true`, the subagent runs detached from this turn. The completion arrives in a later turn as a synthetic user-role message containing its result — you do not need to poll, sleep, or check on its progress. Continue with other work or respond to the user. Never fabricate or predict what the result will say.\n\nDefault to a foreground subagent (omit `run_in_background`) when your next step needs its result — foreground hands the result straight back. Reach for `run_in_background=true` only when you have other work to do while it runs and do not need its result to proceed. Never launch in the background and then immediately wait on it (with `TaskOutput block=true`, sleeping, or otherwise): that just blocks the turn for no benefit — run it in the foreground instead.\n";
+	agent_background_enabled_default = "Subagents run detached whenever task management is available, so the parent remains responsive while delegated work continues. Completion arrives automatically in a later turn. Do not poll, sleep, or block on TaskOutput. Continue with other work or respond to the user. Use TaskUpdate to steer the running subagent and TaskStop only when it must be cancelled. Never fabricate or predict its result.";
 }));
 //#endregion
 //#region ../../packages/agent-core/src/tools/builtin/collaboration/agent.md?raw
@@ -252805,7 +252818,7 @@ function formatBackgroundAgentResult(taskId, handle, description, allowBackgroun
 		"",
 		`description: ${description}`,
 		"",
-		allowBackground ? `next_step: The completion arrives automatically in a later turn — do NOT wait, poll, or call TaskOutput on it; continue with other work or hand back to the user. (If you have nothing to do until it finishes, run such tasks in the foreground next time.)` : "next_step: The completion arrives automatically in a later turn.",
+		allowBackground ? "next_step: The subagent continues independently. Do not wait or poll; remain responsive to the user. Use TaskUpdate to steer it and TaskStop only if it must be cancelled. Its completion arrives automatically in a later turn." : "next_step: The completion arrives automatically in a later turn.",
 		`resume_hint: To continue or recover this same subagent later, call Agent(resume="${handle.agentId}", prompt="..."). The parameter is agent_id ("${handle.agentId}"), NOT task_id ("${taskId}") or source_id from a later <notification>. Recovery cases: a later <notification type="task.lost" | "task.failed" | "task.killed"> for this subagent — its conversation history is preserved across session restarts and resume will pick it up.`
 	].join("\n");
 }
@@ -252844,7 +252857,7 @@ function buildSubagentDescriptions(subagents) {
 		return `${header}\n  Tools: ${subagent.tools.join(", ")}`;
 	}).join("\n");
 }
-var AgentToolInputSchema, BACKGROUND_AGENT_UNAVAILABLE, AgentTool, USER_INTERRUPTED_SUBAGENT_MESSAGE;
+var AgentToolInputSchema, BACKGROUND_AGENT_UNAVAILABLE, AgentTool, USER_INTERRUPTED_SUBAGENT_MESSAGE, resolveSubagentRunMode;
 var init_agent$1 = __esmMin((() => {
 	init_zod$1();
 	init_tool_access();
@@ -252857,6 +252870,7 @@ var init_agent$1 = __esmMin((() => {
 	init_agent_background_disabled();
 	init_agent_background_enabled();
 	init_agent$2();
+	({ resolveSubagentRunMode } = createRequire(import.meta.url)("./bin/subagent-parent-responsiveness.cjs"));
 	AgentToolInputSchema = preprocess((input) => {
 		if (typeof input !== "object" || input === null || Array.isArray(input)) return input;
 		const normalized = { ...input };
@@ -252870,7 +252884,7 @@ var init_agent$1 = __esmMin((() => {
 		description: string().describe("Short task description (3-5 words) for UI display"),
 		subagent_type: string().optional().describe("One of the available agent types (see \"Available agent types\" in this tool description). Defaults to \"coder\" when omitted."),
 		resume: string().optional().describe("Optional agent ID to resume instead of creating a new instance. When set, do not also pass subagent_type — the resumed agent keeps its own type, and supplying both is rejected."),
-		run_in_background: boolean$1().optional().describe("If true, return immediately without waiting for completion. Prefer false unless the task can run independently and there is a clear benefit to not waiting."),
+		run_in_background: boolean$1().optional().describe("Compatibility option. When task management is available, subagents always run detached so the parent remains responsive."),
 		timeout_minutes: number$1().int().min(0).max(10080).optional().describe("Wall-clock interval before the same agent is continued automatically. Defaults to 240 minutes. Set 0 to disable the interval for this run.")
 	}));
 	object({
@@ -252906,14 +252920,18 @@ var init_agent$1 = __esmMin((() => {
 			let profileName = args.subagent_type?.length ? args.subagent_type : "coder";
 			const resumeAgentId = args.resume?.trim();
 			if (resumeAgentId !== void 0 && resumeAgentId.length > 0) profileName = await this.subagentHost.getProfileName?.(resumeAgentId) ?? "subagent";
+			const { runInBackground } = resolveSubagentRunMode({
+				allowBackground: this.allowBackground,
+				requested: args.run_in_background
+			});
 			return {
-				description: `${args.run_in_background === true ? "Launching background" : "Launching"} ${profileName} agent: ${args.description}`,
+				description: `${runInBackground ? "Launching background" : "Launching"} ${profileName} agent: ${args.description}`,
 				accesses: ToolAccesses.none(),
 				display: {
 					kind: "agent_call",
 					agent_name: profileName,
 					prompt: args.prompt,
-					background: args.run_in_background
+					background: runInBackground
 				},
 				approvalRule: this.name,
 				matchesRule: (ruleArgs) => matchesGlobRuleSubject(ruleArgs, profileName),
@@ -252923,14 +252941,17 @@ var init_agent$1 = __esmMin((() => {
 		async execution(args, { toolCallId, signal }) {
 			try {
 				signal.throwIfAborted();
-				const runInBackground = args.run_in_background === true;
+				const { runInBackground } = resolveSubagentRunMode({
+					allowBackground: this.allowBackground,
+					requested: args.run_in_background
+				});
 				const requestedProfileName = args.subagent_type?.length ? args.subagent_type : void 0;
 				const resumeAgentId = args.resume?.trim();
 				if (resumeAgentId !== void 0 && resumeAgentId.length > 0 && requestedProfileName !== void 0) return {
 					output: "Cannot set subagent_type when resuming an existing agent. Resume by agent id only.",
 					isError: true
 				};
-				if (runInBackground && !this.allowBackground) return {
+				if (args.run_in_background === true && !this.allowBackground) return {
 					output: BACKGROUND_AGENT_UNAVAILABLE,
 					isError: true
 				};
@@ -265750,10 +265771,10 @@ var init_agent = __esmMin((() => {
 			return this.resolveEffectiveSystemPrompt(this.config.systemPrompt, this.runtimeSystemPromptAppend);
 		}
 		get fastConversationSystemPrompt() {
-			return [personaSystemBlock(), soulSystemBlock(), identitySystemBlock(), naturalPresenceSystemBlock(), conductSystemBlock(), `## Fast conversation mode
+			return [defaultAnswerLanguageSystemBlock(), personaSystemBlock(), soulSystemBlock(), identitySystemBlock(), naturalPresenceSystemBlock(), conductSystemBlock(), `## Fast conversation mode
 
 - Answer the user's current conversational message directly and concisely.
-- Use the language of the user's latest message unless the persona specifies a language override.
+- Use the language of the user's latest conversational message unless the persona or current session specifies a language override.
 - Do not claim to have inspected files, run commands, used tools, or checked current external state.
 - If the message actually requires work or live information, say that plainly instead of inventing a result.`].filter((block) => block.length > 0).join("\n\n");
 		}
@@ -342504,7 +342525,7 @@ const DEFAULT_INLINE_SUGGEST_LANGUAGES = {
 };
 const DEFAULT_TUI_CONFIG = TuiConfigSchema.parse({
 	theme: "auto",
-	uiLocale: "auto",
+	uiLocale: "en",
 	disablePasteBurst: false,
 	editorCommand: null,
 	notifications: DEFAULT_NOTIFICATIONS_CONFIG,
@@ -419349,6 +419370,7 @@ var { projectUnaddressedTelegramContext } = createRequire(import.meta.url)("./bi
 var { enqueueTelegramUrgent, rewriteTelegramUrgentEnvelope, telegramUrgentMessage } = createRequire(import.meta.url)("./bin/telegram-urgent-policy.cjs");
 var { createDirectFocusController, createDirectReplyTurnStop, enqueueTelegramDirect, readDirectFocusCheckpoint, rewriteTelegramDirectEnvelope, telegramDirectMessage, writeDirectFocusCheckpoint } = createRequire(import.meta.url)("./bin/telegram-direct-focus-policy.cjs");
 var { enqueueTelegramAddressed } = createRequire(import.meta.url)("./bin/telegram-addressed-priority.cjs");
+var { createAddressedChannelFocusStore } = createRequire(import.meta.url)("./bin/telegram-addressed-focus.cjs");
 var { removeQueuedReloadCommands, removeQueuedSlashCommands } = createRequire(import.meta.url)("./bin/reload-queue-policy.cjs");
 const MAX_BUFFERED_CONTEXT_MESSAGES = 20;
 const MAX_BUFFERED_CONTEXT_CHARS = 24e3;
@@ -501854,6 +501876,23 @@ var QueuePaneComponent = class extends Container {
 		return lines;
 	}
 };
+var AddressedChannelFocusPaneComponent = class extends Container {
+	items;
+	constructor(items) {
+		super();
+		this.items = items;
+	}
+	render(width) {
+		const bar = chalk.hex(ACCENT)(LEFT_BAR$1);
+		return this.items.slice(-3).map((item) => {
+			const origin = item.origin.trim().length > 0 ? `${item.origin.trim()}  ` : "Telegram  ";
+			const body = item.text.replaceAll(/\s+/g, " ").trim();
+			const prefix = `${bar} ${currentTheme.fg("primary", "!")} ${currentTheme.fg("textStrong", origin)}`;
+			const available = Math.max(1, width - visibleWidth(prefix));
+			return truncateToWidth(`${prefix}${truncateToWidth(body, available, ELLIPSIS$3)}`, width, ELLIPSIS$3);
+		});
+	}
+};
 //#endregion
 //#region src/tui/utils/refresh-providers.ts
 init_src$3();
@@ -506116,9 +506155,15 @@ var ScrollbackBuffer = class {
 	get totalLines() {
 		return this.archive.totalLines + this.snapshotLines.length;
 	}
+	get activeTurnCount() {
+		return this.archive instanceof SessionScrollbackArchive ? this.archive.activeTurnCount : void 0;
+	}
 	archiveLines(lines) {
 		return this.archive.append(lines);
 	}
+	setActiveTurnCount(count) {
+		return this.archive instanceof SessionScrollbackArchive ? this.archive.setActiveTurnCount(count) : false;
+	}
 	usePersistentArchive(directory, options) {
 		this.releaseArchive();
 		const archive = new SessionScrollbackArchive({
@@ -506515,12 +506560,17 @@ var ScrollbackController = class {
 			reset: !resumeCheckpointRestored,
 			reuse: resumeCheckpointRestored
 		});
-		this.suppressReplayArchiveWrites = resumeCheckpointRestored && loadedExisting;
-		return true;
+		const activeTurnCount = resumeCheckpointRestored && loadedExisting && buffer.totalLines > 0 ? buffer.activeTurnCount : void 0;
+		this.suppressReplayArchiveWrites = resumeCheckpointRestored && loadedExisting && activeTurnCount === void 0;
+		return activeTurnCount;
 	}
 	finishSessionReplay() {
+		this.persistActiveTurnCount(groupTurns(this.state.transcriptEntries).length);
 		this.suppressReplayArchiveWrites = false;
 	}
+	persistActiveTurnCount(count) {
+		this.buffer?.setActiveTurnCount(count);
+	}
 	archiveComponents(components) {
 		const buffer = this.buffer;
 		if (buffer === void 0 || components.length === 0) return components.length === 0;
@@ -509544,6 +509594,21 @@ function createReplayRenderContext() {
 		suppressNextPlanModeOffNotice: false
 	};
 }
+function replayRecordStartsVisibleTurn(record) {
+	if (record?.type !== "message" || record.message?.role !== "user") return false;
+	const message = record.message;
+	if (backgroundOrigin(message) !== void 0) return false;
+	if (message.origin?.kind === "hook_result" || message.origin?.kind === "injection") return false;
+	if (message.origin?.kind === "shell_command") return message.origin.phase === "input";
+	if (message.origin?.kind === "cron_job" || message.origin?.kind === "cron_missed") return false;
+	if (isGoalForkClearedSystemReminder(message)) return false;
+	if (goalOutcomeReminderFromSystemMessage(message) !== null) return false;
+	const skill = skillActivationFromOrigin(message.origin);
+	if (skill !== void 0) return message.origin?.kind === "skill_activation" && message.origin.trigger === "user-slash";
+	const pluginCommand = pluginCommandFromOrigin(message.origin);
+	if (pluginCommand !== void 0) return message.origin?.kind === "plugin_command" && message.origin.trigger === "user-slash";
+	return true;
+}
 function replayEntry(context, kind, content, renderMode, extras = {}) {
 	return {
 		id: nextTranscriptId(),
@@ -509810,9 +509875,9 @@ var SessionReplayRenderer = class {
 				this.host.showError(uiText("replay.error.unavailable"));
 				return false;
 			}
-			this.host.scrollbackController.prepareSessionReplay(main);
+			const activeTurnCount = this.host.scrollbackController.prepareSessionReplay(main);
 			this.hydrateSnapshot(main);
-			await this.renderRecords(main);
+			await this.renderRecords(main, activeTurnCount);
 			this.applyTerminalBackgroundAgentStatuses(main);
 			this.host.mergeAllTurnSteps();
 			this.host.requestTranscriptRender();
@@ -509880,9 +509945,11 @@ var SessionReplayRenderer = class {
 		state.footer.setBackgroundCounts(countActiveBackgroundTasks(sessionEventHandler.backgroundTasks));
 		state.ui.requestRender();
 	}
-	async renderRecords(agent) {
+	async renderRecords(agent, activeTurnCount) {
 		const context = createReplayRenderContext();
-		for (const [recordIndex, record] of agent.replay.entries()) {
+		const startIndex = replayWindowStartIndex(agent.replay, activeTurnCount, replayRecordStartsVisibleTurn);
+		for (let recordIndex = startIndex; recordIndex < agent.replay.length; recordIndex++) {
+			const record = agent.replay[recordIndex];
 			this.renderRecord(context, record);
 			if (shouldYieldSessionReplay(recordIndex + 1, agent.replay.length)) await yieldSessionReplayControl();
 		}
@@ -515175,6 +515242,7 @@ function createTUIState(options) {
 	ui.setSurfaceEnabled(initialAppState.appearance?.surface !== void 0);
 	const transcriptContainer = new GutterContainer(1, 1);
 	const activityContainer = new GutterContainer(1, 1);
+	const channelFocusContainer = new GutterContainer(1, 1);
 	const todoPanelContainer = new GutterContainer(1, 1);
 	const todoPanel = new TodoPanelComponent();
 	const queueContainer = new GutterContainer(1, 1);
@@ -515192,6 +515260,7 @@ function createTUIState(options) {
 		terminal,
 		transcriptContainer,
 		activityContainer,
+		channelFocusContainer,
 		todoPanelContainer,
 		todoPanel,
 		queueContainer,
@@ -516705,6 +516774,9 @@ var BlunTUI = class {
 		this.startupTranscriptNotice = startupInput.startupTranscriptNotice;
 		this.onStartupNoticeShown = startupInput.onStartupNoticeShown;
 		this.state = createTUIState(tuiOptions);
+		this.addressedChannelFocusStore = createAddressedChannelFocusStore({
+			onChange: () => this.updateAddressedChannelFocus()
+		});
 		this.state.loopIndicator.setRefreshHandler(() => {
 			void this.refreshLoopState();
 		});
@@ -517375,6 +517447,7 @@ var BlunTUI = class {
 		ui.clear();
 		ui.addChild(this.state.transcriptContainer);
 		ui.addChild(this.state.activityContainer);
+		ui.addChild(this.state.channelFocusContainer);
 		ui.addChild(this.state.todoPanelContainer);
 		ui.addChild(this.state.queueContainer);
 		ui.addChild(this.state.quotaWarningContainer);
@@ -517383,7 +517456,7 @@ var BlunTUI = class {
 		ui.addChild(this.state.editorContainer);
 		if (ui instanceof BottomPinnedTUI) {
 			ui.pinFromIndex = ui.children.indexOf(this.state.quotaWarningContainer);
-			ui.chromeFromIndex = ui.children.indexOf(this.state.todoPanelContainer);
+			ui.chromeFromIndex = ui.children.indexOf(this.state.channelFocusContainer);
 			ui.overlayRowsProvider = () => this.state.editor.getAutocompleteRows();
 			for (const delay of [
 				0,
@@ -517595,7 +517668,8 @@ var BlunTUI = class {
 			outboxMarker: outboxMarker(),
 			transcriptStart: this.state.transcriptEntries.length,
 			contextOnly: false,
-			directFocus: queued.channelDirect === true
+			directFocus: queued.channelDirect === true,
+			channelFocusId: queued.channelFocusId
 		}]);
 		this.pendingChannelReplyGuards.push(...installedGuards);
 		const inFlight = {
@@ -517649,12 +517723,13 @@ var BlunTUI = class {
 		}
 		return true;
 	}
-	installChannelReplyGuard(chatId, contextOnly) {
+	installChannelReplyGuard(chatId, contextOnly, channelFocusId) {
 		const guard = {
 			chatId,
 			outboxMarker: outboxMarker(),
 			transcriptStart: this.state.transcriptEntries.length,
-			contextOnly
+			contextOnly,
+			channelFocusId
 		};
 		this.pendingChannelReplyGuards.push(guard);
 		return guard;
@@ -517663,6 +517738,18 @@ var BlunTUI = class {
 		const index = this.pendingChannelReplyGuards.indexOf(guard);
 		if (index >= 0) this.pendingChannelReplyGuards.splice(index, 1);
 	}
+	pinAddressedChannelFocus(chatId, origin, text) {
+		return this.addressedChannelFocusStore.pin({ chatId, origin, text });
+	}
+	clearAddressedChannelFocus(chatId) {
+		return this.addressedChannelFocusStore.clearChat(chatId);
+	}
+	updateAddressedChannelFocus() {
+		this.state.channelFocusContainer.clear();
+		const items = this.addressedChannelFocusStore.snapshot();
+		if (items.length > 0) this.state.channelFocusContainer.addChild(new AddressedChannelFocusPaneComponent(items));
+		this.state.ui.requestRender();
+	}
 	commitQueuedSteerAtStepStart(turnId) {
 		const inFlight = this.queueSteerInFlight;
 		if (inFlight === void 0 || inFlight.turnId !== String(turnId)) return;
@@ -517945,11 +518032,12 @@ var BlunTUI = class {
 			this.injectTelegramRemoteCommand(envelope, remoteCommand, acknowledge);
 			return;
 		}
+		const channelFocusId = addressed && urgentEnvelope === void 0 && directEnvelope === void 0 ? this.pinAddressedChannelFocus(routedEnvelope.meta.chat_id, channelOrigin(routedEnvelope), envelope.text) : void 0;
 		injectChannelEnvelope({
 			canDeliver: () => this.session !== void 0 && this.state.appState.model.trim().length > 0,
 			isBusy: () => this.state.queuedMessages.length > 0 || this.queueSteerInFlight !== void 0 || this.deferUserMessages || this.streamingUI.hasActiveTurn() || this.state.appState.streamingPhase !== "idle" || this.state.appState.isCompacting,
 			deliverNow: (modelInput, displayText, origin, contextOnly, channelReportSources) => {
-				this.sendChannelMessageInternal(this.requireSession(), modelInput, displayText, origin, routedEnvelope.meta.chat_id, routedEnvelope.meta["image_path"], contextOnly, false, acknowledge, false, void 0, directEnvelope !== void 0, directFocus.resumeGranted, channelReportSources);
+				this.sendChannelMessageInternal(this.requireSession(), modelInput, displayText, origin, routedEnvelope.meta.chat_id, routedEnvelope.meta["image_path"], contextOnly, false, acknowledge, false, void 0, directEnvelope !== void 0, directFocus.resumeGranted, channelReportSources, channelFocusId);
 			},
 			enqueue: (modelInput, displayText, origin, contextOnly, channelReportSources) => {
 				const item = {
@@ -517962,6 +518050,7 @@ var BlunTUI = class {
 					channelReportSources: channelReportSources,
 					channelContextOnly: contextOnly,
 					channelAcknowledge: acknowledge,
+					...channelFocusId === void 0 ? {} : { channelFocusId },
 					...urgentEnvelope !== void 0 ? { channelUrgent: true } : {},
 					...directEnvelope !== void 0 ? { channelDirect: true, channelDirectResume: directFocus.resumeGranted } : {},
 					...addressed && urgentEnvelope === void 0 && directEnvelope === void 0 ? { channelAddressed: true } : {},
@@ -518119,7 +518208,7 @@ var BlunTUI = class {
 			this.failSessionRequest(uiText("blunTui.session.sendFailed", { error: formatErrorMessage$2(error) }));
 		});
 	}
-	sendChannelMessageInternal(session, modelInput, displayText, origin, channelChatId, channelImagePath, contextOnly = false, transcriptRendered = false, acknowledge, channelAttention = false, queueKey, channelDirect = false, channelDirectResume = false, channelReportSources = []) {
+	sendChannelMessageInternal(session, modelInput, displayText, origin, channelChatId, channelImagePath, contextOnly = false, transcriptRendered = false, acknowledge, channelAttention = false, queueKey, channelDirect = false, channelDirectResume = false, channelReportSources = [], channelFocusId) {
 		armPersonalMemoryRememberIntent(session.id, displayText, {
 			permissionMode: this.state.appState.permissionMode,
 			channel: true
@@ -518139,7 +518228,8 @@ var BlunTUI = class {
 			outboxMarker: outboxMarker(),
 			transcriptStart: this.state.transcriptEntries.length,
 			contextOnly,
-			directFocus: channelDirect
+			directFocus: channelDirect,
+			channelFocusId
 		};
 		if (installedGuard !== void 0) this.pendingChannelReplyGuard = installedGuard;
 		const imagePart = channelImagePath !== void 0 ? buildChannelImagePart(channelImagePath) : void 0;
@@ -518170,6 +518260,7 @@ var BlunTUI = class {
 				channelContextOnly: contextOnly,
 				channelTranscriptRendered: true,
 				channelAcknowledge: acknowledge,
+				...channelFocusId === void 0 ? {} : { channelFocusId, channelAddressed: true },
 				...channelAttention === true ? { channelAttention: true } : {},
 				...channelDirect === true ? { channelDirect: true, channelDirectResume } : {},
 				...queueKey === void 0 ? {} : { queueKey },
@@ -518262,6 +518353,7 @@ var BlunTUI = class {
 				const args = entry.toolCallData?.args;
 				return String(args?.["chat_id"] ?? args?.["chatId"] ?? "") === guard.chatId;
 			}) || outboxGrewForChat(guard.outboxMarker, guard.chatId)) {
+				this.clearAddressedChannelFocus?.(guard.chatId);
 				if (guard.directFocus === true) this.directFocusController.noteReplyDelivered(guard.chatId);
 				continue;
 			}
@@ -518287,6 +518379,7 @@ var BlunTUI = class {
 			if (finalText.length === 0) continue;
 			sendReplyFallback(guard.chatId, finalText, guard.contextOnly).then((sent) => {
 				if (!sent) return;
+				this.clearAddressedChannelFocus?.(guard.chatId);
 				if (guard.directFocus === true) this.directFocusController.noteReplyDelivered(guard.chatId);
 				this.showStatus(uiText("blunTui.telegram.fallbackDelivered"));
 			});
@@ -518530,7 +518623,7 @@ var BlunTUI = class {
 		const activeSession = this.session ?? session;
 		if (item.mode === "channel") {
 			this.harness.withInteractiveAgent(item.agentId ?? "main", () => {
-				this.sendChannelMessageInternal(activeSession, item.text, item.displayText ?? "", item.origin, item.channelChatId, item.channelImagePath, item.channelContextOnly, item.channelTranscriptRendered, item.channelAcknowledge, item.channelAttention, item.queueKey, item.channelDirect, item.channelDirectResume, item.channelReportSources);
+				this.sendChannelMessageInternal(activeSession, item.text, item.displayText ?? "", item.origin, item.channelChatId, item.channelImagePath, item.channelContextOnly, item.channelTranscriptRendered, item.channelAcknowledge, item.channelAttention, item.queueKey, item.channelDirect, item.channelDirectResume, item.channelReportSources, item.channelFocusId);
 			});
 			return;
 		}
@@ -519134,9 +519227,11 @@ var BlunTUI = class {
 			markTranscriptComponent(component, entry);
 			this.state.transcriptContainer.addChild(component);
 		}
-		const trimmed = component !== null && this.isTurnBoundaryComponent(component) ? this.trimTranscriptWindow() : false;
+		const turnBoundary = component !== null && this.isTurnBoundaryComponent(component);
+		const trimmed = turnBoundary ? this.trimTranscriptWindow() : false;
 		const deferReplayWork = this.state.appState.isReplaying;
 		const merged = deferReplayWork ? false : this.mergeCurrentTurnSteps();
+		if (turnBoundary && !deferReplayWork) this.scrollbackController.persistActiveTurnCount(groupTurns(this.state.transcriptEntries).length);
 		if ((component || trimmed || merged) && !deferReplayWork) this.state.ui.requestRender();
 	}
 	appendApprovalTranscriptEntry(request, response) {
@@ -520714,7 +520809,10 @@ function main() {
 		});
 	}).parse(process.argv);
 }
-main();
+function isDirectCliEntry(argvEntry = process.argv[1], moduleFilename = __filename) {
+	return typeof argvEntry === "string" && argvEntry.length > 0 && path.resolve(argvEntry) === path.resolve(moduleFilename);
+}
+if (isDirectCliEntry()) main();
 async function logStartupFailure(operation, error) {
 	log.error("startup failed", {
 		operation,
@@ -520725,4 +520823,4 @@ async function logStartupFailure(operation, error) {
 	} catch {}
 }
 //#endregion
-export { configureTelegramPluginLaunchMode, handleMainCommand, main };
+export { configureTelegramPluginLaunchMode, createBlunHarness, createBlunHostIdentity, handleMainCommand, isDirectCliEntry, main };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "blun-king-cli",
-  "version": "9.1.462",
+  "version": "9.1.464",
   "description": "BLUN CLI - your own AI agent with a Telegram channel. Get it done. With BLUN.",
   "license": "MIT",
   "bin": {