dsh-tg-bridge 1.2.9 → 1.3.0

package/README.md

@@ -159,6 +159,31 @@ Telegram → bridge.mjs → dsh --profile headless --json → ответ
 процесс CLI, который умирает после ответа; поэтому «нет процесса DSH» между
 ходами — это норма, а не сбой.
 
+### Дополнение во время хода
+
+Если написать в тему, пока ход ещё идёт, сообщение не встаёт в очередь за ним:
+мост кладёт задание в `~/.dsh/tg-bridge/steer/`, плагин `dsh-steer-inbox`
+отдаёт его живому агенту на следующем шаге, и тот сразу отвечает короткой
+строкой в чат — что делает сейчас и куда поставил добавку. Если агент молчит
+90 секунд, мост сам пишет одну нейтральную строку, чтобы не было тишины.
+
+Нужен плагин из этого репозитория:
+
+```bash
+dsh plugin --profile headless add link:<путь-к-репозиторию>/plugin/steer-inbox
+```
+
+и строка в `~/.dsh/profiles/headless/cordis.patch.yml`:
+
+```yaml
+- insert:
+    - id: steer-inbox
+      name: 'dsh-steer-inbox'
+```
+
+Мост сам проверяет профиль: если строки нет, он не пишет задание (иначе оно
+просто истечёт), а ведёт себя как раньше — ставит сообщение в очередь.
+
 ## Безопасность
 
 - `config.json`, `state.json`, `pending/`, логи — в `.gitignore`, в репозиторий

package/bridge.mjs

@@ -23,6 +23,8 @@ import net from 'node:net';
 dns.setDefaultResultOrder('ipv4first');
 net.setDefaultAutoSelectFamily(false);
 import { noticeIsObsolete } from './queue-notice.mjs';
+import { immediateKind } from './immediate.mjs';
+import { writeSteerJob } from './steer-queue.mjs';
 import { handleControl, CONTROL_COMMANDS } from './control.mjs';
 import { renderPrices } from './prices.mjs';
 import { t, resolveLang } from './i18n.mjs';
@@ -36,6 +38,10 @@ const STATE = join(DIR, 'state.json');
 const LOG = join(DIR, 'bridge.log');
 const CRED = join(DSH_HOME, '.credentials.yaml');
 const PENDING_DIR = join(DIR, 'pending');
+const STEER_DIR = join(DIR, 'steer');
+// The helper the agent calls to confirm an addition in the chat while the turn
+// is still running. Lives next to the bridge so an installed copy works too.
+const SAY = join(DIR, 'say.mjs');
 const DONE_FILE = join(DIR, 'done.json');
 const RESTART_MARKER = join(DIR, 'restart.pending');
 // `/restart confirm` leaves a note here for the process that replaces it: the
@@ -65,7 +71,24 @@ try {
   }
 } catch {}
 writeFileSync(PID_FILE, String(process.pid), 'utf8');
-process.on('exit', () => {
+/**
+ * Silent deaths are undebuggable.
+ *
+ * A bridge launched by Task Scheduler has no console, so an uncaught error used
+ * to kill the poller with nothing in bridge.log but "bridge started" — from the
+ * outside the bot simply stopped answering. Every fatal path now leaves a line
+ * with the stack in bridge.log, and the exit hook records the code so a kill by
+ * Task Scheduler (0xC000013A) is distinguishable from a Node crash (1).
+ */
+process.on('uncaughtException', (error) => {
+  log(`FATAL uncaught: ${error && error.stack ? error.stack : error}`);
+  process.exit(1);
+});
+process.on('unhandledRejection', (reason) => {
+  log(`FATAL unhandled rejection: ${reason && reason.stack ? reason.stack : reason}`);
+});
+process.on('exit', (code) => {
+  log(`bridge exiting code=${code}`);
   try {
     if (readFileSync(PID_FILE, 'utf8').trim() === String(process.pid)) unlinkSync(PID_FILE);
   } catch {}
@@ -79,6 +102,8 @@ const config = {
 };
 /** Turns currently running, keyed like sessions — `/stop` kills one. */
 const activeTurns = new Map();
+/** Session id each running turn actually adopted, learned from its `session` event. */
+const liveSessions = new Map();
 /** Wall-clock start of the running turn per session key, for the queue notice. */
 const turnStartedAt = new Map();
 try {
@@ -474,33 +499,13 @@ function commandOf(text) {
   return `/${match[1].toLowerCase().replace(/[.-]+/g, '')}`;
 }
 
-/**
- * Commands that must run *now*, not behind the turn they are about.
- *
- * Everything in a topic used to be queued, so `/stop` waited for the very turn
- * it was supposed to kill — on 2026-10-24 a 26-minute turn swallowed `/stop`
- * and the person got "ход уже идёт" instead of an interruption. These few
- * commands touch no turn state, so they can run concurrently with one.
- */
-const IMMEDIATE_COMMANDS = new Set([
-  'stop',
-  'logs',
-  'status',
-  'help',
-  'doctor',
-  'restart',
-]);
-
 /** Canonical immediate command name for a message, or '' when it must queue. */
 function immediateCommandOf(text) {
   const trimmed = String(text ?? '').trim();
   if (!trimmed.startsWith('/')) return '';
-  const head = trimmed.split(/\s+/)[0];
+  const [head, ...rest] = trimmed.split(/\s+/);
   const collapsed = commandOf(head).replace(/^\//, '');
-  if (collapsed === 'apprestart' || collapsed === 'apprestartconfirm' || collapsed === 'restartconfirm') {
-    return 'restart';
-  }
-  return IMMEDIATE_COMMANDS.has(collapsed) ? collapsed : '';
+  return immediateKind(collapsed, rest);
 }
 
 /**
@@ -759,6 +764,9 @@ function runTurn(task, sessionId, key = '', onEvent = null, extraArgs = [], cwd
     child.on('close', (code) => {
       clearTimeout(timer);
       if (key) activeTurns.delete(key);
+      // No live process means no agent to steer; a job written now would wait
+      // for the next turn instead of the current one.
+      if (key) liveSessions.delete(key);
       // Keep the whole diagnostic: the CLI prints the useful phrase
       // ("pending (waiting for service: speechToText)") on the lines AFTER the
       // one-line summary, and trimming early hid the real cause from the chat.
@@ -1223,6 +1231,9 @@ ${t(lang, 'help.body')}`,
   const telemetry = { steps: 0, tools: 0, inputTokens: 0, cacheReadTokens: 0, model: config.primaryModel || 'deepseek-v4.1-flash-1017' };
   const onEvent = (event) => {
     try {
+      // The id of the session this process actually works in. A new topic has
+      // no id until the CLI emits one, and steering needs it before that.
+      if (event.type === 'session' && event.sessionId) liveSessions.set(key, event.sessionId);
       progress.handle(event);
       if (event.type === 'tool_call') {
         telemetry.tools += 1;
@@ -1420,6 +1431,58 @@ async function clearBusyNotice(key) {
   }
 }
 
+/**
+ * Whether this profile can receive mid-turn steers. The bridge only writes a
+ * job when the `steer-inbox` plugin is actually wired into the profile; without
+ * it the file would sit unread until it expired, and the message would be lost.
+ * In that case the message queues the old way.
+ */
+let steerReady;
+function steerAvailable() {
+  if (steerReady !== undefined) return steerReady;
+  try {
+    const patch = readFileSync(join(DSH_HOME, 'profiles', config.profile || 'headless', 'cordis.patch.yml'), 'utf8');
+    steerReady = /steer-inbox/.test(patch);
+  } catch {
+    steerReady = false;
+  }
+  return steerReady;
+}
+
+/**
+ * Hand a message to the turn that is already running.
+ *
+ * The turn is a separate process, so the bridge writes a job the `steer-inbox`
+ * plugin picks up and feeds to `agent.steer()` — next-step input. The agent is
+ * told (in the job, by the plugin) to send one short line into the chat via
+ * say.mjs; the fallback below covers a model that stays silent.
+ */
+function steerRunningTurn(msg, text, sessionId, thread) {
+  const key = sessionKey(msg.chat.id, thread);
+  const lang = resolveLang(state, key, msg, config);
+  const job = writeSteerJob(STEER_DIR, {
+    sessionId,
+    text,
+    chatId: msg.chat.id,
+    threadId: thread,
+    lang,
+    say: SAY,
+  });
+  log(`steer ${job.id} -> ${sessionId} (${text.length} chars)`);
+  const timer = setTimeout(async () => {
+    try {
+      if (existsSync(join(STEER_DIR, 'acks', `${job.id}.json`))) return;
+      if (!activeTurns.has(key)) return; // turn ended; its answer is the reply
+      log(`steer ${job.id} unacknowledged after 90s; sending fallback`);
+      await send(msg.chat.id, t(lang, 'steer.ackFallback'), thread);
+    } catch (error) {
+      log(`steer fallback failed: ${error.message}`);
+    }
+  }, 90_000);
+  timer.unref?.();
+  return job;
+}
+
 function enqueue(key, task, onBusy) {
   const prev = queues.get(key) || Promise.resolve();
   const queued = queues.has(key);
@@ -1734,6 +1797,22 @@ async function main() {
         .catch((error) => log(`command ${immediate} failed: ${error.message}`));
       return;
     }
+    // A plain message during a running turn is an addition to that work, not a
+    // new turn: steer it into the live agent instead of queueing it behind the
+    // very turn it is meant to change.
+    if (msg.text && !msg.text.trimStart().startsWith('/') && config.steerDuringTurn !== false && steerAvailable()) {
+      const sessionId = liveSessions.get(queueKey) || state.sessions[queueKey];
+      if (activeTurns.has(queueKey) && sessionId) {
+        try {
+          const job = steerRunningTurn(msg, msg.text.trim(), sessionId, thread);
+          log(`steer handled outside the queue: ${job.id}`);
+          ack(update.update_id);
+        } catch (error) {
+          log(`steer write failed: ${error.message}`);
+        }
+        return;
+      }
+    }
     enqueue(
       queueKey,
       async () => {

package/i18n.mjs

@@ -25,16 +25,17 @@ const DICT = {
     'btn.retry': 'Retry',
     'btn.doctor': 'Doctor',
     'status.cache': 'cache',
-    'status.more': '…and {n} more',
-    'status.cacheLine': '🧠 cache: {pct}% ({k}k from cache)',
-    'msg.topicLog': '📌 New topic: {preview}\n→ work happens in the topic, this is the log.',
-    'msg.transcribing': '🎤 Transcribing…',
+    'status.more': '…and {n} more',
+    'status.cacheLine': '🧠 cache: {pct}% ({k}k from cache)',
+    'msg.topicLog': '📌 New topic: {preview}\n→ work happens in the topic, this is the log.',
+    'msg.transcribing': '🎤 Transcribing…',
     'status.steps': 'steps',
     'status.thinking': 'waiting for the model',
     'err.timeout': 'no activity for {min} min — turn interrupted',
     'err.generic': 'something went wrong',
-    'msg.busy.since': '⏳ The previous turn has been running for {min} min — your message is queued.\nIf it stalls, /stop interrupts it and I take yours right away.',
-    'msg.busy.now': '⏳ The previous turn is still running — your message is queued.\nIf it stalls, /stop interrupts it and I take yours right away.',
+    'msg.busy.since': '⏳ The previous turn has been running for {min} min — your message is queued.\nIf it stalls, /stop interrupts it and I take yours right away.',
+    'msg.busy.now': '⏳ The previous turn is still running — your message is queued.\nIf it stalls, /stop interrupts it and I take yours right away.',
+    'steer.ackFallback': '↪ Got the addition — folding it into this turn.',
     'msg.started': 'Telegram bridge for DSH is running (headless). Send a task; /help for commands.',
     'msg.restarted': 'Bridge restarted — back online (pid {pid}).\nThe topic and session are the same; keep going.',
     'cmd.restart.prompt': 'To restart the bridge: /restart confirm. For the DSH app: /app restart confirm.',
@@ -81,20 +82,21 @@ const DICT = {
     'btn.retry': 'Повторить',
     'btn.doctor': 'Диагноз',
     'status.cache': 'кэш',
-    'status.more': '…и ещё {n}',
-    'status.cacheLine': '🧠 кэш: {pct}% ({k}k из кэша)',
-    'msg.topicLog': '📌 Новая тема: {preview}\n→ работа идёт в теме, здесь — лог.',
-    'msg.transcribing': '🎤 Расшифровываю…',
+    'status.more': '…и ещё {n}',
+    'status.cacheLine': '🧠 кэш: {pct}% ({k}k из кэша)',
+    'msg.topicLog': '📌 Новая тема: {preview}\n→ работа идёт в теме, здесь — лог.',
+    'msg.transcribing': '🎤 Расшифровываю…',
     'status.steps': 'шагов',
     'status.thinking': 'жду модель',
     'err.timeout': 'нет активности {min} мин — ход прерван',
     'err.generic': 'что-то пошло не так',
-    'msg.busy.since': '⏳ Предыдущий ход идёт уже {min} мин — твоё сообщение в очереди.\nЕсли это затянулось, /stop прервёт ход, и я сразу возьмусь за твоим.',
-    'msg.busy.now': '⏳ Предыдущий ход ещё идёт — твоё сообщение в очереди.\nЕсли это затянулось, /stop прервёт ход, и я сразу возьмусь за твоим.',
+    'msg.busy.since': '⏳ Предыдущий ход идёт уже {min} мин — твоё сообщение в очереди.\nЕсли это затянулось, /stop прервёт ход, и я сразу возьмусь за твоим.',
+    'msg.busy.now': '⏳ Предыдущий ход ещё идёт — твоё сообщение в очереди.\nЕсли это затянулось, /stop прервёт ход, и я сразу возьмусь за твоим.',
+    'steer.ackFallback': '↪ Принял дополнение — учту его в этом же ходе.',
     'msg.started': 'Telegram-мост DSH запущен (headless). Пиши задачу; /help — команды.',
-    'msg.restarted': 'Мост перезапущен — на связи (pid {pid}).\nТема и сессия прежние, можно продолжать.',
-    'cmd.restart.prompt': 'Перезапуск моста: /restart confirm. Приложение DSH: /app restart confirm.',
-    'cmd.restart.started': 'Перезапускаю мост…',
+    'msg.restarted': 'Мост перезапущен — на связи (pid {pid}).\nТема и сессия прежние, можно продолжать.',
+    'cmd.restart.prompt': 'Перезапуск моста: /restart confirm. Приложение DSH: /app restart confirm.',
+    'cmd.restart.started': 'Перезапускаю мост…',
     'msg.unknownCommand': 'Неизвестная команда: {cmd}. Открой /help — там всё, что умеет бот.',
     'msg.langSet': 'Язык переключён на русский.',
     'cmd.help.title': 'Команды',
@@ -137,20 +139,21 @@ const DICT = {
     'btn.retry': '重试',
     'btn.doctor': '诊断',
     'status.cache': '缓存',
-    'status.more': '…还有 {n} 条',
-    'status.cacheLine': '🧠 缓存：{pct}%（{k}k 来自缓存）',
-    'msg.topicLog': '📌 新主题：{preview}\n→ 工作在主题里进行，这里是日志。',
-    'msg.transcribing': '🎤 正在转写…',
+    'status.more': '…还有 {n} 条',
+    'status.cacheLine': '🧠 缓存：{pct}%（{k}k 来自缓存）',
+    'msg.topicLog': '📌 新主题：{preview}\n→ 工作在主题里进行，这里是日志。',
+    'msg.transcribing': '🎤 正在转写…',
     'status.steps': '步',
     'status.thinking': '等待模型',
     'err.timeout': '{min} 分钟无活动 — 已中断',
     'err.generic': '出现错误',
-    'msg.busy.since': '⏳ 上一轮已运行 {min} 分钟 —— 你的消息在队列中。\n如果太久，/stop 会中断它，我马上处理你的消息。',
-    'msg.busy.now': '⏳ 上一轮还在运行 —— 你的消息在队列中。\n如果太久，/stop 会中断它，我马上处理你的消息。',
+    'msg.busy.since': '⏳ 上一轮已运行 {min} 分钟 —— 你的消息在队列中。\n如果太久，/stop 会中断它，我马上处理你的消息。',
+    'msg.busy.now': '⏳ 上一轮还在运行 —— 你的消息在队列中。\n如果太久，/stop 会中断它，我马上处理你的消息。',
+    'steer.ackFallback': '↪ 收到补充，会在本轮里一并处理。',
     'msg.started': 'DSH 的 Telegram 桥已启动（headless）。直接发送任务；/help 查看命令。',
-    'msg.restarted': '桥已重启，连接正常（pid {pid}）。\n主题和会话不变，可以继续。',
-    'cmd.restart.prompt': '重启桥：/restart confirm。重启 DSH 应用：/app restart confirm。',
-    'cmd.restart.started': '正在重启桥…',
+    'msg.restarted': '桥已重启，连接正常（pid {pid}）。\n主题和会话不变，可以继续。',
+    'cmd.restart.prompt': '重启桥：/restart confirm。重启 DSH 应用：/app restart confirm。',
+    'cmd.restart.started': '正在重启桥…',
     'msg.unknownCommand': '未知命令：{cmd}。打开 /help 查看机器人支持的全部命令。',
     'msg.langSet': '界面语言已切换为中文。',
     'cmd.help.title': '命令',

package/immediate.mjs

@@ -0,0 +1,56 @@
+// Which control commands may run while a turn is still working?
+//
+// Everything in a topic used to be queued, so `/stop` waited for the very turn
+// it was supposed to kill. The rule here is not "important commands", it is
+// "commands that neither read nor write the state of the running turn".
+//
+// Groups:
+//   * always immediate — read-only reports and turn control;
+//   * immediate only without arguments — the bare form reports, the form with
+//     an argument changes state (`/soul <text>`, `/lang en`);
+//   * `/plugins` without an action — the list; with add/remove/disable/enable
+//     it installs plugins, which must queue like any other mutation;
+//   * everything else queues, because it changes the session the turn is using
+//     (`/model`, `/new`, `/resume`, `/cd`, `/send`, `/seed`, `/plugin`).
+
+const PLUGIN_ACTIONS = new Set(['add', 'remove', 'disable', 'enable']);
+
+const ALWAYS = new Set([
+  // Turn control.
+  'stop',
+  'restart',
+  // Reports: they read profiles, sessions, skills and the price table, but
+  // touch neither the queue nor the session of the running turn.
+  'status',
+  'logs',
+  'help',
+  'doctor',
+  'models',
+  'sessions',
+  'skills',
+  'prices',
+]);
+
+const BARE_ONLY = new Set([
+  'soul', // `/soul` reads AGENTS.md, `/soul <text>` rewrites it
+  'lang', // `/lang` reports the current language, `/lang en` switches it
+]);
+
+/**
+ * Canonical immediate command name, or '' when the message must queue.
+ * `name` is the command without the slash and without a bot mention,
+ * `args` is everything after it, already split.
+ */
+export function immediateKind(name, args = []) {
+  const command = String(name ?? '').toLowerCase();
+  if (command === 'apprestart' || command === 'apprestartconfirm' || command === 'restartconfirm') {
+    return 'restart';
+  }
+  if (ALWAYS.has(command)) return command;
+  if (command === 'plugins') {
+    const [action = ''] = args;
+    return PLUGIN_ACTIONS.has(String(action).toLowerCase()) ? '' : 'plugins';
+  }
+  if (BARE_ONLY.has(command) && args.length === 0) return command;
+  return '';
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-tg-bridge",
-  "version": "1.2.9",
+  "version": "1.3.0",
   "description": "Telegram bridge for DeepSeek Harness: text, voice, photos and project-per-topic sessions without opening the desktop app",
   "type": "module",
   "main": "bridge.mjs",
@@ -45,6 +45,10 @@
     "LICENSE",
     "config.example.json",
     "patches/",
-    "queue-notice.mjs"
+    "queue-notice.mjs",
+    "immediate.mjs",
+    "say.mjs",
+    "steer-queue.mjs",
+    "plugin/"
   ]
 }

package/plugin/steer-inbox/index.js

@@ -0,0 +1,111 @@
+// dsh-steer-inbox — file-based mid-turn steering for DSH.
+//
+// A turn is one process, so an outside caller (the Telegram bridge) cannot
+// reach the running agent's inbox directly. This plugin runs inside that
+// process, watches a directory, and hands each file to the live agent's
+// `steer()` — next-step input, not a queued next turn — which is what makes
+// "добавь ещё вот это" land inside the current work instead of after it.
+import { mkdirSync, readFileSync, readdirSync, renameSync, statSync, unlinkSync, appendFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+
+/** Cordis plugin name (loader row id is `steer-inbox`). */
+const name = 'steer-inbox';
+/** `ctx.agents` is the live-agent registry this plugin steers. */
+const inject = ['agents'];
+
+const HOME = homedir();
+const DSH_HOME = process.env.DSH_HOME || join(HOME, '.dsh');
+const DEFAULT_DIR = join(DSH_HOME, 'tg-bridge', 'steer');
+const LOG_DIR = join(DSH_HOME, 'storages', 'steer-inbox');
+
+function log(line) {
+  try {
+    mkdirSync(LOG_DIR, { recursive: true });
+    appendFileSync(join(LOG_DIR, 'steer.ndjson'), `${new Date().toISOString()} ${line}\n`, 'utf8');
+  } catch {}
+}
+
+function apply(ctx, config = {}) {
+  const dir = config.dir || DEFAULT_DIR;
+  const doneDir = join(dir, 'done');
+  try {
+    mkdirSync(dir, { recursive: true });
+    mkdirSync(doneDir, { recursive: true });
+  } catch {}
+
+  const tick = () => {
+    let files;
+    try {
+      files = readdirSync(dir).filter((f) => f.endsWith('.json'));
+    } catch {
+      return;
+    }
+    for (const file of files) {
+      const full = join(dir, file);
+      let job;
+      try {
+        job = JSON.parse(readFileSync(full, 'utf8'));
+      } catch {
+        continue; // half-written; the writer renames into place atomically
+      }
+      // A job written for a turn that already ended will never match a live
+      // agent again; without this it would sit in the directory forever and
+      // could steer a much later session that reuses the id.
+      try {
+        if (Date.now() - statSync(full).mtimeMs > 10 * 60 * 1000) {
+          unlinkSync(full);
+          log(`expired ${file}`);
+          continue;
+        }
+      } catch {}
+      const handle = job.sessionId ? ctx.agents.get(job.sessionId) : undefined;
+      if (!handle) continue; // not this process; leave it for the right one
+      // `get()` has returned the Agent itself in practice and an AgentHandle in
+      // the docs; accept either instead of betting on one shape.
+      const agent = typeof handle.steer === 'function' ? handle : handle.agent;
+      if (typeof agent?.steer !== 'function') {
+        log(`no steer() on the live agent for ${job.sessionId}`);
+        continue;
+      }
+      try {
+        // The addition lands inside the current work. The agent is also told to
+        // send one short line into the chat right away — otherwise the person
+        // sees nothing until the very end of a long turn and assumes the
+        // addition was lost.
+        const sayPath = job.say || join(DSH_HOME, 'tg-bridge', 'say.mjs');
+        const line = [
+          '',
+          '---',
+          '[mid-turn addition from the person in Telegram]',
+          'Before your next tool call, send them ONE short line in their own language: what you are doing now and where this addition fits.',
+          `Use exactly: node "${sayPath}" --steer ${job.id} "one short line"`,
+          'Then continue the work and include this addition. Do not repeat that line in the final answer.',
+        ].join('\n');
+        agent.steer({
+          content: [{ type: 'text', text: `${String(job.text ?? '')}${line}` }],
+          source: { kind: 'tg-bridge' },
+        });
+        log(`steered ${job.sessionId} (${String(job.text ?? '').length} chars) id=${job.id}`);
+        try {
+          const target = join(doneDir, file);
+          try { unlinkSync(target); } catch {}
+          renameSync(full, target);
+        } catch {}
+      } catch (error) {
+        log(`steer failed for ${job.sessionId}: ${error?.message ?? error}`);
+        // A malformed job must not be retried forever.
+        try { renameSync(full, `${full}.failed`); } catch {}
+      }
+    }
+  };
+
+  ctx.effect(() => {
+    const timer = setInterval(tick, 500);
+    timer.unref?.();
+    log(`watching ${dir} (pid ${process.pid})`);
+    return () => clearInterval(timer);
+  }, 'steer-inbox.watch');
+}
+
+export { name, inject, apply };

package/plugin/steer-inbox/package.json

@@ -0,0 +1,21 @@
+{
+  "name": "dsh-steer-inbox",
+  "version": "0.1.0",
+  "description": "Watches ~/.dsh/tg-bridge/steer for JSON jobs and steers the live agent (next-step input) instead of queueing another turn.",
+  "type": "module",
+  "main": "index.js",
+  "exports": {
+    ".": "./index.js",
+    "./package.json": "./package.json"
+  },
+  "dsh": {
+    "compatibility": {
+      "dsh": ">=0.2.1-rc.1 <0.3.0",
+      "profiles": [
+        "headless",
+        "sdk"
+      ]
+    }
+  },
+  "license": "MIT"
+}

package/say.mjs

@@ -0,0 +1,109 @@
+#!/usr/bin/env node
+// say.mjs — one short line from the agent into the Telegram chat, mid-turn.
+//
+// The agent calls this right after it picks up a mid-turn addition, so the
+// person sees "принял, делаю X, добавку поставлю после Y" while the turn is
+// still running instead of silence until the end.
+//
+//   node say.mjs --steer <job-id> "text"
+//   node say.mjs --chat <chat-id> [--thread <id>] "text"
+//
+// With `--steer` the chat/thread come from the job file and an ack marker is
+// written, which suppresses the bridge's fallback line.
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+
+const DSH_HOME = process.env.DSH_HOME || join(homedir(), '.dsh');
+const STEER = join(DSH_HOME, 'tg-bridge', 'steer');
+const ACKS = join(STEER, 'acks');
+
+function findToken() {
+  const env = (process.env.DSH_TELEGRAM_BOT_TOKEN || '').trim();
+  if (env) return env;
+  try {
+    const text = readFileSync(join(DSH_HOME, '.credentials.yaml'), 'utf8');
+    const m = text.match(/^\s*(DSH_TELEGRAM_BOT_TOKEN[A-Z0-9_]*):\s*["']?([^"'\s]+)/m);
+    if (m) return m[2];
+  } catch {}
+  return '';
+}
+
+function jobOf(id) {
+  for (const path of [join(STEER, 'done', `${id}.json`), join(STEER, `${id}.json`)]) {
+    try {
+      if (existsSync(path)) return { path, job: JSON.parse(readFileSync(path, 'utf8')) };
+    } catch {}
+  }
+  return null;
+}
+
+function usage() {
+  console.error('usage: node say.mjs --steer <id> "text" | --chat <id> [--thread <id>] "text"');
+  process.exit(2);
+}
+
+function parse(argv) {
+  const out = { chatId: 0, threadId: 0, steer: '', text: '' };
+  const rest = [];
+  for (let i = 0; i < argv.length; i += 1) {
+    const arg = argv[i];
+    if (arg === '--steer') out.steer = argv[++i] || '';
+    else if (arg === '--chat') out.chatId = Number(argv[++i] || 0);
+    else if (arg === '--thread') out.threadId = Number(argv[++i] || 0);
+    else rest.push(arg);
+  }
+  out.text = rest.join(' ').trim();
+  return out;
+}
+
+async function main() {
+  const args = parse(process.argv.slice(2));
+  if (!args.text) usage();
+
+  let chatId = args.chatId;
+  let threadId = args.threadId;
+  let jobPath = '';
+  if (args.steer) {
+    const found = jobOf(args.steer);
+    if (!found) {
+      console.error(`steer job ${args.steer} not found — the turn may have ended`);
+      process.exit(3);
+    }
+    chatId = Number(found.job.chatId || 0);
+    threadId = Number(found.job.threadId || 0);
+    jobPath = found.path;
+  }
+  if (!chatId) usage();
+
+  const token = findToken();
+  if (!token) {
+    console.error('bot token not found (DSH_TELEGRAM_BOT_TOKEN or ~/.dsh/.credentials.yaml)');
+    process.exit(5);
+  }
+
+  const body = { chat_id: chatId, text: args.text, disable_web_page_preview: true };
+  if (threadId > 0) body.message_thread_id = threadId;
+  const res = await fetch(`https://api.telegram.org/bot${token}/sendMessage`, {
+    method: 'POST',
+    headers: { 'content-type': 'application/json' },
+    body: JSON.stringify(body),
+  });
+  const data = await res.json().catch(() => ({}));
+  if (!data.ok) {
+    console.error(`telegram: ${data.description || res.status}`);
+    process.exit(4);
+  }
+  if (args.steer) {
+    try {
+      mkdirSync(ACKS, { recursive: true });
+      writeFileSync(join(ACKS, `${args.steer}.json`), JSON.stringify({ at: Date.now(), messageId: data.result.message_id, job: jobPath }), 'utf8');
+    } catch {}
+  }
+  console.log(`sent ${data.result.message_id}`);
+}
+
+main().catch((error) => {
+  console.error(String(error?.message ?? error));
+  process.exit(1);
+});

package/steer-queue.mjs

@@ -0,0 +1,32 @@
+// Writing a mid-turn steer job.
+//
+// The bridge cannot reach the agent's inbox: a turn is a separate process. It
+// drops a JSON file into `~/.dsh/tg-bridge/steer/`, the `steer-inbox` plugin
+// notices it within 500 ms and calls `agent.steer()` — next-step input, so the
+// addition lands in the work already running instead of behind it.
+//
+// The file is written to a dot-prefixed temp name and renamed into place, so
+// the plugin can never read half a job.
+import { mkdirSync, renameSync, writeFileSync } from 'node:fs';
+import { randomBytes } from 'node:crypto';
+import { join } from 'node:path';
+
+export function newSteerId() {
+  return `${Date.now().toString(36)}-${randomBytes(3).toString('hex')}`;
+}
+
+/**
+ * @param {string} dir      steer directory
+ * @param {object} job      {sessionId, text, chatId, threadId, lang, say}
+ * @returns {object} the written job, including its `id` and `at`
+ */
+export function writeSteerJob(dir, job) {
+  const id = job.id || newSteerId();
+  const payload = { ...job, id, at: Date.now() };
+  mkdirSync(dir, { recursive: true });
+  const final = join(dir, `${id}.json`);
+  const tmp = join(dir, `.${id}.tmp`);
+  writeFileSync(tmp, JSON.stringify(payload), 'utf8');
+  renameSync(tmp, final);
+  return payload;
+}