@soffits/dsh-telegram-bot 0.4.4 → 0.5.0

package/MAINTAINING.md

@@ -10,7 +10,7 @@ This repository is a maintained fork of [Boobaw/dsh-telegram-bot](https://github
 - Session titles are `Telegram-<person>-<DSH title>` (`plannedTitle` in `src/topics.js`): DSH has no title hook, so `syncTopicTitle` re-appends each generated `session/title` with the prefix and the same source (automatic titling keeps running), and `startTopicTitle` calls `sessionTitle.refresh` at the first model request, because the `Telegram-<person>-<topic name>` placeholder is a user title that stops automatic titling. `<person>` comes from `userNames` / `userNamesFile`, else the chat's Telegram name (`chatNames` in the state file, learned from messages or `getChat`). Each session record keeps the label its title carries (`titlePerson`), so a changed name still finds the old prefix. `migrateSessionTitles` brings every bound session to the current form once the bot connects, reading titles from the log first and opening only sessions whose title changes. DSH's session header keeps only its own fields (dsh-session copies `cwd`, `parentSession`, `agentPreset` and the rest by name), so the source and person are not in session meta; DSH 0.2.2 has experimental plugin records (`appendPluginRecord` in dsh-session) that could carry them in the log later. Topic renames record a `telegram-topic` notice as a `user/message` (`recordNote`): session search indexes only message, tool and todo events, not titles or queued inbox items.
 - Deleted topics are forgotten as soon as any Bot API call reports them gone (`forgetGoneTopic`).
 - Chat-wide commands sent in All are answered in All; the topic Telegram made for them is deleted.
-- Sender labels: each Telegram prompt names who wrote it.
+- Sender labels: each Telegram prompt names who wrote it, in a text line for the model and as `source.principal` for readers (`src/sender.js`). DSH writes `principal` itself only for non-owner callers of its session controller, and the bot hands text prompts to that controller, which builds the message, so the bot remembers the sender by request id and records it on the message in an `agent/pre-step` listener (DSH lets that hook replace a step's messages); messages the bot builds itself get it directly. Sends recorded in a bound session carry the sender (job, session or label) the same way.
 - Voice messages, audio and round videos: downloaded, transcribed (DSH speech-to-text or a configured command) and passed with their file path.
 - Messages sent during a running turn are steered into it (`src/steer.js`): text through `sessionController.prompt({ mode: 'steer' })`, the Web UI's own call, and prompts with stored attachments through `agent.steer`, the method that mode uses. DSH keeps the turn going while its next-step inbox holds input and starts a new turn when input is left after `turn/end`, so a message that lands as the turn ends is still answered; `chat.steerFollow` shows that turn in the topic even with `mirrorTurns` off, and is cleared at the first `turn/end` that leaves the inbox empty. Prompts reach DSH in order (`admitInOrder`). `busyMessages: queue` keeps upstream's bot-side queue.
 - Stickers: received ones are attached as images (thumbnail or first frame for animated and video stickers) and kept in a library (`src/stickers.js`) with the agent's meaning notes; the `telegram_sticker` tool finds, views, notes, loads sets and sends them through `sendToTopic`.
@@ -36,4 +36,4 @@ git push origin main
 
 Conflicts usually land in `src/app.js` (most of the bridge lives there), `README.md` and the `name` and `version` lines of `package.json`. Keep the fork's own name and version: it is published on npm as `@soffits/dsh-telegram-bot` with its own semver line (0.4.0 was the first release, on top of upstream 0.3.0), so bump the minor version for features and upstream merges and the patch version for fixes, and name the merged upstream version in the merge or release commit. Make sure `client.js` still matches `src/client.js` after the merge (`cmp client.js src/client.js`).
 
-Fork-only code is kept in separate files where that is natural (`src/topics.js`, `src/outbox.js`, `src/message-context.js`, `src/sent-log.js`, `src/voice.js`, `src/steer.js`, `src/models.js`, `src/final-text.js`, `bin/dsh-telegram-send.js`, `test/fake-dsh.js`, `test/fork-features.test.js`, `test/message-context.test.js`, `test/sent-log.test.js`, `test/steer.test.js`, `test/models.test.js`, `test/final-text.test.js`, `test/voice.test.js`), so most upstream edits apply without touching it.
+Fork-only code is kept in separate files where that is natural (`src/topics.js`, `src/outbox.js`, `src/message-context.js`, `src/sent-log.js`, `src/voice.js`, `src/steer.js`, `src/sender.js`, `src/models.js`, `src/final-text.js`, `bin/dsh-telegram-send.js`, `test/fake-dsh.js`, `test/fork-features.test.js`, `test/message-context.test.js`, `test/sent-log.test.js`, `test/steer.test.js`, `test/sender.test.js`, `test/models.test.js`, `test/final-text.test.js`, `test/voice.test.js`), so most upstream edits apply without touching it.

package/README.md

@@ -25,7 +25,7 @@ BotFather: **Bot Settings → Threaded mode → Enable**. Leave **Disallow users
 - One Telegram topic per DSH session; Web and Telegram use the same session.
 - You create the topics. A new topic asks which workspace to use, then whether to start a new session or continue an existing one from that workspace. The message that opened the topic runs once the session is chosen.
 - Topic names are yours: the bot never renames a topic after the session title. `/rename` renames it on request.
-- A Telegram session is titled `Telegram-<person>-<what the conversation is about>` in DSH, for example `Telegram-Livia-Fix empty Telegram sessions`, so the sidebar shows where each session comes from and whose chat it is. `<person>` is the name set for the chat's user in `userNames` or `userNamesFile`, else the user's Telegram first name; in a group it is the group's title. The last part is DSH's own title (its title model, or the first words of the first message); until it exists the topic name stands in for it. Sessions with titles from earlier versions (`<topic name> · <task>`, a bare topic name) are moved to this form when the bot starts. A title someone types for the session is left alone.
+- A Telegram session is titled `Telegram-<person>-<what the conversation is about>` in DSH, for example `Telegram-Ana-Plan a weekend trip`, so the sidebar shows where each session comes from and whose chat it is. `<person>` is the name set for the chat's user in `userNames` or `userNamesFile`, else the user's Telegram first name; in a group it is the group's title. The last part is DSH's own title (its title model, or the first words of the first message); until it exists the topic name stands in for it. Sessions with titles from earlier versions (`<topic name> · <task>`, a bare topic name) are moved to this form when the bot starts. A title someone types for the session is left alone.
 - Renaming a topic also records a short note in its session, such as `Telegram topic renamed: "Old" -> "New" (thread 123)`, so searching earlier sessions finds it under either name.
 - A session the bot creates for a topic is never handed out as a blank session. DSH's **New conversation** reuses a session that has not started a turn yet; the bot therefore starts one empty turn as soon as it creates a session, and stops it before any model request. Without this, a topic session waiting for its first message could be picked up by the Web UI, and that Web chat would be mirrored into the topic.
 - Deleted topics clean themselves up: when Telegram answers any call for a topic with "message thread not found", `TOPIC_ID_INVALID` or `TOPIC_DELETED`, the bot drops that topic's session binding and name and logs it. The session stays in DSH. A closed topic keeps its binding, since it can be reopened.
@@ -42,7 +42,7 @@ BotFather: **Bot Settings → Threaded mode → Enable**. Leave **Disallow users
 - `ask_user_question` support: options, multi-select, custom answers and plan review.
 - Documents and photos sent in a session topic are saved as DSH attachments and passed to the agent.
 - Voice messages, audio files and round video messages are saved as files and transcribed; the agent gets the transcript and the file's path, so it can check a doubtful transcript against the recording. See [Voice messages](#voice-messages).
-- Every prompt from Telegram starts with a line naming the sender, such as `[Telegram message from Ana Silva (@ana, user id 123)]`, so the agent knows who is writing when several allowed users share the bot. Prompts typed in the Web UI are not labelled.
+- Every prompt from Telegram starts with a line naming the sender, such as `[Telegram message from Ana Silva (@ana, user id 123)]`, so the agent knows who is writing when several allowed users share the bot. Prompts typed in the Web UI are not labelled. The sender is also recorded as data on the prompt's source as `principal`, the field DSH uses for the caller behind a user message: `{ kind: 'telegram-user', channel: 'telegram', id: '123', name: 'Ana Silva', username: 'ana', chat: { id, thread, name } }`, where `chat` is the chat, its topic thread and the topic's name. Scripts that read session logs can use it instead of parsing the line.
 - Replies, quotes and forwards keep their context. The agent sees the text of the replied-to message (or only the quoted part), who wrote it and when; a replied-to photo or document is attached too. A forwarded message is labelled with its origin (person, hidden account, group or channel with a message link) and original date. Several messages forwarded together become one prompt, and forwarded text never runs as a command. Long quoted text is cut at about 2,000 characters with a note.
 - Replies to messages sent into a topic by a script, job, plugin or another session (see [Send to a topic](#send-to-a-topic)) also carry the full original text, when it was sent, and the sending session and job, even if the topic has moved to a new session since.
 - `/new`, `/workspace`, `/last`, `/goal`, `/rename`, `/topic`, `/fork`, `/clear`, `/stop`, `/restart`, `/status` and `/menu`.
@@ -145,7 +145,7 @@ Private-chat topics send with `message_thread_id`. If Telegram answers `message
 
 ## Send to a topic
 
-Scripts, scheduled jobs, other plugins and agents can post into a topic by its numeric thread id (`/id` in the topic shows it). The message (text, files, a sticker) appears in the topic and is also recorded in the session bound to that topic, without starting a turn, labelled with who sent it. This holds for the bound session's own sends too, so a Web UI reader of that session sees the same pictures, files and stickers: pictures and stickers (as their still image) are recorded as images, other files as file attachments. An idle session gets the record at once; a busy one gets it at its next step. Thread ids belong to one chat, so the message goes to the chat the bot saw that thread in (its binding or known name), not the chat that last wrote to the bot. A thread id the bot does not know in any chat is an error; nothing is created. In the rare case two chats have a topic with the same thread id, the send fails until the caller names the chat (`chat`, `--chat`). Topic names are only labels, never addresses. A known topic with no session gets a new one first, made the way `/new` makes it (the configured working directory and preset, titled after the topic), so the message is recorded; only a topic whose user is still choosing its session just shows the message, and the result says so (`note`). If no session can take the record, the message is still sent and the result carries `recordError`.
+Scripts, scheduled jobs, other plugins and agents can post into a topic by its numeric thread id (`/id` in the topic shows it). The message (text, files, a sticker) appears in the topic and is also recorded in the session bound to that topic, without starting a turn, labelled with who sent it. The record's source (kind `telegram-post`) names the topic it went to (`channel: 'telegram'`, `chatId`, `threadId`, `topic`) and the sender as `principal`: `{ kind: 'cron-job', channel: 'cron', id, name, sessionId? }` for a scheduled job, `{ kind: 'dsh-session', channel: 'dsh', id }` for a DSH session, or `{ kind: 'external', channel: 'external', id: <label> }` for a caller that gave only a label. This holds for the bound session's own sends too, so a Web UI reader of that session sees the same pictures, files and stickers: pictures and stickers (as their still image) are recorded as images, other files as file attachments. An idle session gets the record at once; a busy one gets it at its next step. Thread ids belong to one chat, so the message goes to the chat the bot saw that thread in (its binding or known name), not the chat that last wrote to the bot. A thread id the bot does not know in any chat is an error; nothing is created. In the rare case two chats have a topic with the same thread id, the send fails until the caller names the chat (`chat`, `--chat`). Topic names are only labels, never addresses. A known topic with no session gets a new one first, made the way `/new` makes it (the configured working directory and preset, titled after the topic), so the message is recorded; only a topic whose user is still choosing its session just shows the message, and the result says so (`note`). If no session can take the record, the message is still sent and the result carries `recordError`.
 
 The bot also remembers each such send (`$DSH_HOME/telegram/sent-messages.json`: the last 1,000 sends from the past 180 days, text up to 20,000 characters). When someone replies to or quotes one of those messages, the agent gets the whole original text, however many Telegram messages it was split into, with its send time, job name and sending session, and a hint to open that session for more context. This works after `/new` too, when the current session never saw the message.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@soffits/dsh-telegram-bot",
-  "version": "0.4.4",
+  "version": "0.5.0",
   "description": "Telegram sessions, topics, model controls and approvals for DeepSeek Harness.",
   "type": "module",
   "main": "./index.js",

package/src/app.js

@@ -35,8 +35,9 @@ import {
   toTelegramMarkdown,
   toolArg,
 } from './formatting.js'
-import { admitText } from './admission.js'
+import { admitText, promptRequestId } from './admission.js'
 import { STEER_REACTION, busyMode, clearTelegramInbox, hasPendingInput, steerPrompt } from './steer.js'
+import { createPrincipalTagger, sendPrincipal, telegramUserPrincipal } from './sender.js'
 import { loadState, STATE_PATH } from './state.js'
 import { createUpdateAdmission } from './update-ledger.js'
 import { publishStatus } from './status.js'
@@ -129,6 +130,10 @@ export function apply(ctx, config) {
     })
   /** Ids of legacy follow-up messages the bridge submitted from Telegram. */
   const telegramMessageIds = new Set()
+  // Telegram senders by `<chatId>:<messageId>`, kept from routing until the
+  // prompt is handed to DSH (a topic binding or the queue may come between).
+  const promptSenders = new Map()
+  const principals = createPrincipalTagger()
 
   /**
    * Persist the chat → session mapping atomically.
@@ -2754,7 +2759,7 @@ export function apply(ctx, config) {
       }
       let requestId
       try {
-        requestId = await steerPrompt(ctx, agent, { sessionId: chat.sessionId, chatId: chat.chatId, messageId, text, attachments }, signal)
+        requestId = await steerPrompt(ctx, agent, { sessionId: chat.sessionId, chatId: chat.chatId, messageId, text, attachments, principal: promptPrincipal(chat, messageId) }, signal, principals)
       } catch (error) {
         // Not admitted: the bot's queue still delivers it after the turn.
         reportError('steer', error)
@@ -2846,14 +2851,16 @@ export function apply(ctx, config) {
       const agent = await ensureAgent(chat)
       await unarchiveForTopic(chat)
       let admitted = false
+      const principal = promptPrincipal(chat, messageId)
       if (nativeText) {
+        principals.remember(promptRequestId(chat.chatId, messageId), principal)
         admitted = admitText(ctx, { sessionId: chat.sessionId, chatId: chat.chatId, messageId, text }, signal)
         if (admitted !== false) await admitted
       }
       if (!admitted) {
         const id = randomUUID()
         telegramMessageIds.add(id)
-        agent.followup({ id, role: 'user', content: [...(text.trim().length === 0 ? [] : [{ type: 'text', text }]), ...attachments], source: { kind: 'user' } })
+        agent.followup({ id, role: 'user', content: [...(text.trim().length === 0 ? [] : [{ type: 'text', text }]), ...attachments], source: { kind: 'user', ...(principal === undefined ? {} : { principal }) } })
       }
       // The turn/end listener finalizes the Telegram turn. whenIdle is only a
       // fallback for the turn that started this epoch, never a queued turn.
@@ -3952,13 +3959,17 @@ export function apply(ctx, config) {
    *   line the model also reads, `from` the request's sender.
    * @returns the message source.
    */
-  function postSource({ header, threadId, topic, from, self }) {
+  function postSource({ header, chatId, threadId, topic, from, self }) {
     const job = typeof from?.job === 'string' && from.job.trim().length > 0 ? from.job.trim() : null
     const label = typeof from?.label === 'string' && from.label.trim().length > 0 ? from.label.trim() : null
+    const principal = sendPrincipal(from)
     return {
       kind: POST_SOURCE_KIND,
       form: 'notice',
       summary: header.slice(0, 120),
+      ...(principal === undefined ? {} : { principal }),
+      channel: 'telegram',
+      chatId: String(chatId),
       threadId,
       topic: topic ?? null,
       job,
@@ -4105,7 +4116,7 @@ export function apply(ctx, config) {
           id: randomUUID(),
           role: 'user',
           content,
-          source: postSource({ header, threadId, topic: target.name, from: request?.from, self }),
+          source: postSource({ header, chatId, threadId, topic: target.name, from: request?.from, self }),
         })
         recorded = true
       } catch (error) {
@@ -5873,6 +5884,36 @@ export function apply(ctx, config) {
     return { text, attachments, messageId: message.message_id, from: message.from }
   }
 
+  /**
+   * Keep who wrote a Telegram message until its prompt reaches DSH.
+   * @param chatId - Telegram chat.
+   * @param messageId - Telegram message id.
+   * @param from - Telegram `from` of the message.
+   */
+  function rememberSender(chatId, messageId, from) {
+    if (!Number.isSafeInteger(messageId) || from === undefined || from === null) return
+    const key = `${chatId}:${messageId}`
+    promptSenders.delete(key)
+    promptSenders.set(key, from)
+    if (promptSenders.size > 1024) promptSenders.delete(promptSenders.keys().next().value)
+  }
+
+  /**
+   * The sender of a Telegram message, recorded on its prompt's source.
+   * @param chat - the topic the prompt runs in.
+   * @param messageId - Telegram message id.
+   * @returns the principal, or undefined when the sender is not known.
+   */
+  function promptPrincipal(chat, messageId) {
+    const from = promptSenders.get(`${chat.chatId}:${messageId}`)
+    if (from === undefined) return undefined
+    return telegramUserPrincipal(from, {
+      chatId: chat.chatId,
+      threadId: chat.threadId,
+      topic: typeof chat.threadId === 'number' ? topicNameFor(chat.chatId, chat.threadId) : undefined,
+    })
+  }
+
   /**
    * Route one prompt: a new topic from All, the workspace picker in a topic
    * without a session, or a turn in the bound session.
@@ -5886,6 +5927,7 @@ export function apply(ctx, config) {
     // Say who is writing: several allowed users may share one bot.
     const label = senderLabel(prompt.from)
     if (label !== undefined) prompt = { ...prompt, text: prompt.text.length > 0 ? `${label}\n${prompt.text}` : label }
+    rememberSender(chatId, prompt.messageId, prompt.from)
     const route = routeMessage({ threadId, inSession: typeof chatState.sessionId === 'string' })
     if (route === 'new-topic') {
       await createNewSessionTopic(chatId, threadId, signal, defaultWorkspaceCwd(), prompt.text, prompt.attachments, prompt.messageId)
@@ -6527,6 +6569,8 @@ export function apply(ctx, config) {
     return () => outbox.stop()
   }, 'dsh-telegram-bot: outbox')
 
+  // Record each Telegram sender on the prompt the session controller built for it.
+  ctx.on('agent/pre-step', (payload, next) => principals.preStep(payload, next), { global: true })
   // Host-wide feeds: every session's events, whichever client started the
   // turn. Only sessions bound to a topic are mirrored.
   ctx.on('session/event', (session, event) => {

package/src/sender.js

@@ -0,0 +1,134 @@
+/**
+ * Who sent a message, as data on the message itself.
+ *
+ * DSH's field for the caller behind a user message is `source.principal`:
+ * the session controller writes it for callers other than the owner, so an
+ * absent principal means the owner. The bot admits every Telegram prompt as
+ * the owner, so it fills the field itself, and also on the copies of sends it
+ * records in bound sessions. Readers then get the sender without parsing the
+ * sender line, which stays in the text for the model.
+ *
+ * Every principal has `kind`, `channel` and `id`, and `name` when one is
+ * known; the other fields depend on the kind. None carries a credential, so
+ * all are safe in a session log.
+ */
+
+/** Remembered prompts waiting for their step; the oldest go first past this. */
+export const MAX_PENDING_PRINCIPALS = 1024
+
+function nonEmpty(value) {
+  return typeof value === 'string' && value.trim().length > 0 ? value.trim() : undefined
+}
+
+/**
+ * The Telegram user who wrote a message, and where.
+ * @param user - Telegram `from` of the message.
+ * @param where - `{ chatId, threadId, topic }`: the chat, its topic thread and the topic's name.
+ * @returns the principal, or undefined without a sender.
+ */
+export function telegramUserPrincipal(user, { chatId, threadId, topic } = {}) {
+  if (user === undefined || user === null || user.id === undefined || user.id === null) return undefined
+  const name = [user.first_name, user.last_name].map(nonEmpty).filter((part) => part !== undefined).join(' ')
+  const username = nonEmpty(user.username)
+  const chat = chatId === undefined || chatId === null
+    ? undefined
+    : {
+        id: String(chatId),
+        ...(Number.isSafeInteger(threadId) && threadId > 0 ? { thread: threadId } : {}),
+        ...(nonEmpty(topic) === undefined ? {} : { name: nonEmpty(topic) }),
+      }
+  return {
+    kind: 'telegram-user',
+    channel: 'telegram',
+    id: String(user.id),
+    ...(name.length > 0 ? { name } : {}),
+    ...(username === undefined ? {} : { username }),
+    ...(chat === undefined ? {} : { chat }),
+  }
+}
+
+/**
+ * The sender of a send into a topic, from the request's `from`: a scheduled
+ * job, else a DSH session, else the free-form label of an outside caller.
+ * @param from - `{ job?, jobId?, sessionId?, label? }`.
+ * @returns the principal, or undefined when the request names no sender.
+ */
+export function sendPrincipal(from) {
+  const job = nonEmpty(from?.job)
+  const jobId = nonEmpty(from?.jobId)
+  const sessionId = nonEmpty(from?.sessionId)
+  const label = nonEmpty(from?.label)
+  if (job !== undefined || jobId !== undefined) {
+    return {
+      kind: 'cron-job',
+      channel: 'cron',
+      id: jobId ?? job,
+      ...(job === undefined ? {} : { name: job }),
+      ...(sessionId === undefined ? {} : { sessionId }),
+    }
+  }
+  if (sessionId !== undefined) {
+    return { kind: 'dsh-session', channel: 'dsh', id: sessionId, ...(label === undefined ? {} : { name: label }) }
+  }
+  if (label !== undefined) return { kind: 'external', channel: 'external', id: label, name: label }
+  return undefined
+}
+
+/**
+ * A frozen copy of a message whose source records its sender.
+ * @param message - the user message.
+ * @param principal - its sender.
+ * @returns the copy; the message itself when there is no principal.
+ */
+export function withPrincipal(message, principal) {
+  if (principal === undefined) return message
+  return Object.freeze({ ...message, source: Object.freeze({ ...message.source, principal: deepFreeze(principal) }) })
+}
+
+function deepFreeze(value) {
+  if (typeof value === 'object' && value !== null && !Object.isFrozen(value)) {
+    for (const child of Object.values(value)) deepFreeze(child)
+    Object.freeze(value)
+  }
+  return value
+}
+
+/**
+ * Principals for prompts the bot hands to DSH's session controller, which
+ * builds the message itself. The bot remembers the sender by request id
+ * before the hand-over; `preStep`, an `agent/pre-step` listener, records it
+ * on the message as it enters a step, so it is in the session log with the
+ * message (DSH lets that hook replace the messages of a step).
+ * @param limit - most principals remembered at once.
+ */
+export function createPrincipalTagger(limit = MAX_PENDING_PRINCIPALS) {
+  const pending = new Map()
+  return {
+    /** Remember the sender of the prompt with this request id. */
+    remember(requestId, principal) {
+      if (typeof requestId !== 'string' || principal === undefined) return
+      pending.delete(requestId)
+      pending.set(requestId, principal)
+      if (pending.size > limit) pending.delete(pending.keys().next().value)
+    },
+    /** Pending principals, for tests. */
+    get size() {
+      return pending.size
+    },
+    /** `agent/pre-step` listener: record remembered senders on the step's messages. */
+    async preStep(_payload, next) {
+      const decision = await next()
+      if (decision?.kind !== 'enter' || pending.size === 0 || !Array.isArray(decision.messages)) return decision
+      let changed = false
+      const messages = decision.messages.map((message) => {
+        const rpcId = message?.source?.kind === 'user' ? message.source.rpcId : undefined
+        const principal = typeof rpcId === 'string' ? pending.get(rpcId) : undefined
+        if (principal === undefined || message.source.principal !== undefined) return message
+        pending.delete(rpcId)
+        changed = true
+        return withPrincipal(message, principal)
+      })
+      return changed ? { ...decision, messages } : decision
+    },
+  }
+}

package/src/steer.js

@@ -52,20 +52,24 @@ function hasRequest(agent, requestId) {
  * dropped. A request id already admitted is skipped, so it is never sent twice.
  * @param ctx - plugin context.
  * @param agent - the session's live agent.
- * @param prompt - `{ sessionId, chatId, messageId, text, attachments }`.
+ * @param prompt - `{ sessionId, chatId, messageId, text, attachments, principal }`;
+ *   `principal` is the sender recorded on the message's source.
  * @param signal - request lifetime.
+ * @param tagger - remembers the principal of a prompt the session controller
+ *   builds (see `createPrincipalTagger`).
  * @returns the request id, or `undefined` when this DSH cannot steer.
  */
-export async function steerPrompt(ctx, agent, { sessionId, chatId, messageId, text, attachments = [] }, signal) {
+export async function steerPrompt(ctx, agent, { sessionId, chatId, messageId, text, attachments = [], principal }, signal, tagger) {
   const requestId = steerRequestId(chatId, messageId)
   const content = [...(text.trim().length === 0 ? [] : [{ type: 'text', text }]), ...attachments]
   const controller = ctx.get('sessionController')
   if (attachments.length === 0 && content.length > 0 && typeof controller?.prompt === 'function') {
+    tagger?.remember(requestId, principal)
     await controller.prompt({ sessionId, requestId, mode: 'steer', content }, signal)
     return requestId
   }
   if (hasRequest(agent, requestId)) return requestId
-  const message = { id: randomUUID(), role: 'user', content, source: { kind: 'user', rpcId: requestId } }
+  const message = { id: randomUUID(), role: 'user', content, source: { kind: 'user', rpcId: requestId, ...(principal === undefined ? {} : { principal }) } }
   if (typeof agent?.steer === 'function') agent.steer(message)
   else if (typeof agent?.send === 'function') agent.send(message, 'next-step', true)
   else return undefined