dsh-tg-bridge 1.5.0 → 1.5.2

package/README.md

@@ -206,6 +206,20 @@ and a line in `~/.dsh/profiles/headless/cordis.patch.yml`:
 The bridge checks the profile itself: if the line is missing, it does not write the task
 (it would just expire) and behaves as before, queueing the message.
 
+### Live thoughts
+
+The agent can leave a short decision trail inside the progress message instead of sending
+extra chat messages:
+
+```bash
+node ~/.dsh/tg-bridge/say.mjs --thought "checking why the watchdog fired twice"
+```
+
+The note is appended to `~/.dsh/tg-bridge/thoughts/<chat>_<thread>.jsonl`; the progress
+message shows the last two as `💭` lines. Inside a turn the chat and thread come from
+`DSH_TG_CHAT` / `DSH_TG_THREAD`, so the command needs no ids. `--thought` never sends a
+Telegram message on its own.
+
 ### Goals and tasks
 
 A topic carries its own goal and checklist, so the aim survives `/new`, a

package/bridge.mjs

@@ -44,6 +44,7 @@ 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');
+const THOUGHT_DIR = join(DIR, 'thoughts');
 // 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');
@@ -735,6 +736,9 @@ function runTurn(task, sessionId, key = '', onEvent = null, extraArgs = [], cwd
       cwd: cwd && existsSync(cwd) ? cwd : config.cwd,
       env: {
         ...process.env,
+        DSH_TG_KEY: key,
+        DSH_TG_CHAT: String(key).split(':')[0] || '',
+        DSH_TG_THREAD: String(key).split(':')[1] || '0',
         ELECTRON_RUN_AS_NODE: '1',
         UNOROUTER_API_KEY: readSecret('UNOROUTER_API_KEY'),
         // Free fallback providers: their keys live next to the main one and are
@@ -871,6 +875,34 @@ async function startProgress(chatId, threadId, lang = 'ru') {
   let dirty = false;
   let timer = null;
 
+  // Short "💭" notes the agent appends with `say.mjs --thought`. The progress
+  // message shows the last two, so the person sees the decision trail without
+  // a second stream of chat messages.
+  const thoughtFile = join(THOUGHT_DIR, `${chatId}_${threadId || 0}.jsonl`);
+  let thoughts = [];
+  try {
+    mkdirSync(THOUGHT_DIR, { recursive: true });
+    writeFileSync(thoughtFile, '');
+  } catch {}
+  const thoughtTimer = setInterval(() => {
+    let next = [];
+    try {
+      next = readFileSync(thoughtFile, 'utf8')
+        .split('\n')
+        .filter(Boolean)
+        .slice(-2)
+        .map((line) => {
+          try { return String(JSON.parse(line).text || '').slice(0, 140); } catch { return ''; }
+        })
+        .filter(Boolean);
+    } catch {}
+    if (next.join('\n') !== thoughts.join('\n')) {
+      thoughts = next;
+      schedule();
+    }
+  }, 3000);
+  thoughtTimer.unref?.();
+
   const body = (final = false) => {
     const seconds = Math.round((Date.now() - started) / 1000);
     const head = final
@@ -880,6 +912,7 @@ async function startProgress(chatId, threadId, lang = 'ru') {
     // shell commands read as noise on a phone.
     const tail = steps.slice(-3).map((line) => `• ${line}`).join('\n');
     const more = steps.length > 3 ? `\n${t(lang, 'status.more', { n: steps.length - 3 })}` : '';
+    const mind = thoughts.length ? `\n${thoughts.map((line) => `💭 ${line}`).join('\n')}` : '';
     // The cache line belongs to the outcome, not to every intermediate edit.
     const cache = final && usage.cacheReadTokens
       ? `\n${t(lang, 'status.cacheLine', {
@@ -887,7 +920,7 @@ async function startProgress(chatId, threadId, lang = 'ru') {
         k: Math.round(usage.cacheReadTokens / 1000),
       })}`
       : '';
-    return (tail ? `${head}\n${tail}${more}${cache}` : `${head}${cache}`);
+    return (tail ? `${head}${mind}\n${tail}${more}${cache}` : `${head}${mind}${cache}`);
   };
 
   try {
@@ -922,7 +955,7 @@ async function startProgress(chatId, threadId, lang = 'ru') {
     }
   };
 
-  const schedule = () => {
+  function schedule() {
     dirty = true;
     if (timer) return;
     timer = setTimeout(async () => {
@@ -932,7 +965,7 @@ async function startProgress(chatId, threadId, lang = 'ru') {
       await edit(body());
     }, 3500);
     timer.unref?.();
-  };
+  }
 
   return {
     /** Keep the clock moving during long model thinking: the elapsed time is
@@ -969,6 +1002,7 @@ async function startProgress(chatId, threadId, lang = 'ru') {
     },
     async finish(result) {
       clearTimeout(timer);
+      clearInterval(thoughtTimer);
       if (result?.error) {
         // A failed turn leaves the status message as the error report and swaps
         // «Стоп» for «Повторить»: the person's next move is a retry, not a stop.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-tg-bridge",
-  "version": "1.5.0",
+  "version": "1.5.2",
   "description": "Telegram bridge for DeepSeek Harness: text, voice, photos and project-per-topic sessions without opening the desktop app",
   "type": "module",
   "main": "plugin-bridge.mjs",

package/say.mjs

@@ -7,16 +7,21 @@
 //
 //   node say.mjs --steer <job-id> "text"
 //   node say.mjs --chat <chat-id> [--thread <id>] "text"
+//   node say.mjs --thought "short note"   (chat/thread come from DSH_TG_CHAT/DSH_TG_THREAD)
+//
+// `--thought` does not send a message: it appends to the turn's thought file,
+// and the live progress message shows the last two notes as 💭 lines.
 //
 // 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 { appendFileSync, 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');
+const THOUGHTS = join(DSH_HOME, 'tg-bridge', 'thoughts');
 
 function findToken() {
   const env = (process.env.DSH_TELEGRAM_BOT_TOKEN || '').trim();
@@ -39,18 +44,19 @@ function jobOf(id) {
 }
 
 function usage() {
-  console.error('usage: node say.mjs --steer <id> "text" | --chat <id> [--thread <id>] "text"');
+  console.error('usage: node say.mjs --steer <id> "text" | --chat <id> [--thread <id>] "text" | --thought "text"');
   process.exit(2);
 }
 
 function parse(argv) {
-  const out = { chatId: 0, threadId: 0, steer: '', text: '' };
+  const out = { chatId: 0, threadId: 0, steer: '', thought: false, 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 if (arg === '--thought') out.thought = true;
     else rest.push(arg);
   }
   out.text = rest.join(' ').trim();
@@ -61,8 +67,8 @@ async function main() {
   const args = parse(process.argv.slice(2));
   if (!args.text) usage();
 
-  let chatId = args.chatId;
-  let threadId = args.threadId;
+  let chatId = args.chatId || Number(process.env.DSH_TG_CHAT || 0);
+  let threadId = args.threadId || Number(process.env.DSH_TG_THREAD || 0);
   let jobPath = '';
   if (args.steer) {
     const found = jobOf(args.steer);
@@ -76,6 +82,19 @@ async function main() {
   }
   if (!chatId) usage();
 
+  if (args.thought) {
+    try {
+      mkdirSync(THOUGHTS, { recursive: true });
+      const file = join(THOUGHTS, `${chatId}_${threadId || 0}.jsonl`);
+      appendFileSync(file, `${JSON.stringify({ at: Date.now(), text: args.text })}\n`, 'utf8');
+      console.log(file);
+    } catch (error) {
+      console.error(String(error?.message ?? error));
+      process.exit(6);
+    }
+    return;
+  }
+
   const token = findToken();
   if (!token) {
     console.error('bot token not found (DSH_TELEGRAM_BOT_TOKEN or ~/.dsh/.credentials.yaml)');