@vellumai/assistant 0.11.10-dev.202609092113.0fb45bc → 0.11.10-dev.202609092213.434c99d

package/node_modules/@vellumai/ces-client/node_modules/@vellumai/service-contracts/src/reactions.ts

@@ -41,6 +41,12 @@ export const ReactionEmojiFieldsSchema = z.object({
 });
 export type ReactionEmojiFields = z.infer<typeof ReactionEmojiFieldsSchema>;
 
+/** The typed fields with the kind and name known. */
+export type ReactionEmojiIdentity = ReactionEmojiFields & {
+  emojiKind: ReactionEmojiKind;
+  emojiName: string;
+};
+
 /**
  * The typed emoji fields a source actually carries, with undefined ones
  * omitted: an absent key and a present-but-undefined one serialize alike, but the
@@ -96,7 +102,7 @@ export function parseDiscordEmojiMention(
  */
 export function classifyReactionEmojiSpelling(
   emoji: string,
-): ReactionEmojiFields & { emojiKind: ReactionEmojiKind; emojiName: string } {
+): ReactionEmojiIdentity {
   const custom = parseDiscordEmojiMention(emoji);
   if (custom) {
     // The plain `<:name:id>` form says nothing about animation: the
@@ -123,7 +129,7 @@ export function classifyReactionEmojiSpelling(
  */
 export function reactionEmojiIdentity(
   reaction: { emoji: string } & ReactionEmojiFields,
-): ReactionEmojiFields & { emojiKind: ReactionEmojiKind; emojiName: string } {
+): ReactionEmojiIdentity {
   return reaction.emojiKind !== undefined && reaction.emojiName !== undefined
     ? {
         ...pickReactionEmojiFields(reaction),

package/node_modules/@vellumai/gateway-client/node_modules/@vellumai/service-contracts/src/reactions.ts

@@ -41,6 +41,12 @@ export const ReactionEmojiFieldsSchema = z.object({
 });
 export type ReactionEmojiFields = z.infer<typeof ReactionEmojiFieldsSchema>;
 
+/** The typed fields with the kind and name known. */
+export type ReactionEmojiIdentity = ReactionEmojiFields & {
+  emojiKind: ReactionEmojiKind;
+  emojiName: string;
+};
+
 /**
  * The typed emoji fields a source actually carries, with undefined ones
  * omitted: an absent key and a present-but-undefined one serialize alike, but the
@@ -96,7 +102,7 @@ export function parseDiscordEmojiMention(
  */
 export function classifyReactionEmojiSpelling(
   emoji: string,
-): ReactionEmojiFields & { emojiKind: ReactionEmojiKind; emojiName: string } {
+): ReactionEmojiIdentity {
   const custom = parseDiscordEmojiMention(emoji);
   if (custom) {
     // The plain `<:name:id>` form says nothing about animation: the
@@ -123,7 +129,7 @@ export function classifyReactionEmojiSpelling(
  */
 export function reactionEmojiIdentity(
   reaction: { emoji: string } & ReactionEmojiFields,
-): ReactionEmojiFields & { emojiKind: ReactionEmojiKind; emojiName: string } {
+): ReactionEmojiIdentity {
   return reaction.emojiKind !== undefined && reaction.emojiName !== undefined
     ? {
         ...pickReactionEmojiFields(reaction),

package/node_modules/@vellumai/gateway-client/src/outbound-contract.ts

@@ -287,6 +287,14 @@ export const ChannelDeliveryResultSchema = z.object({
   ok: z.boolean(),
   /** The message timestamp returned by the delivery endpoint. */
   ts: z.string().optional(),
+  /**
+   * Every provider post the text of this delivery created, in send order, in
+   * the channel's own id space: one id for a single post, one per chunk when
+   * the channel split the text. Posts made for attachments are not included.
+   * A recorder needs every one of these, since a reaction, edit, or delete
+   * can name any chunk; `ts` alone names at most one.
+   */
+  messageIds: z.array(z.string()).optional(),
 });
 
 export type ChannelDeliveryResult = z.infer<typeof ChannelDeliveryResultSchema>;

package/node_modules/@vellumai/service-contracts/src/reactions.ts

@@ -41,6 +41,12 @@ export const ReactionEmojiFieldsSchema = z.object({
 });
 export type ReactionEmojiFields = z.infer<typeof ReactionEmojiFieldsSchema>;
 
+/** The typed fields with the kind and name known. */
+export type ReactionEmojiIdentity = ReactionEmojiFields & {
+  emojiKind: ReactionEmojiKind;
+  emojiName: string;
+};
+
 /**
  * The typed emoji fields a source actually carries, with undefined ones
  * omitted: an absent key and a present-but-undefined one serialize alike, but the
@@ -96,7 +102,7 @@ export function parseDiscordEmojiMention(
  */
 export function classifyReactionEmojiSpelling(
   emoji: string,
-): ReactionEmojiFields & { emojiKind: ReactionEmojiKind; emojiName: string } {
+): ReactionEmojiIdentity {
   const custom = parseDiscordEmojiMention(emoji);
   if (custom) {
     // The plain `<:name:id>` form says nothing about animation: the
@@ -123,7 +129,7 @@ export function classifyReactionEmojiSpelling(
  */
 export function reactionEmojiIdentity(
   reaction: { emoji: string } & ReactionEmojiFields,
-): ReactionEmojiFields & { emojiKind: ReactionEmojiKind; emojiName: string } {
+): ReactionEmojiIdentity {
   return reaction.emojiKind !== undefined && reaction.emojiName !== undefined
     ? {
         ...pickReactionEmojiFields(reaction),

package/node_modules/@vellumai/slack-text/src/emoji.test.ts

@@ -20,6 +20,12 @@ describe("slackEmojiCharacter", () => {
     expect(glyph(slackEmojiCharacter("thumbsup::skin-tone-3"))).toBe("👍🏼");
   });
 
+  test("a same-tone composite repeats the tone for each person", () => {
+    expect(
+      glyph(slackEmojiCharacter("people_holding_hands::skin-tone-3")),
+    ).toBe(glyph("🧑🏼‍🤝‍🧑🏼"));
+  });
+
   test("places the tone inside a multi-person sequence", () => {
     expect(glyph(slackEmojiCharacter("woman-raising-hand::skin-tone-2"))).toBe(
       glyph("🙋🏻‍♀️"),

package/node_modules/@vellumai/slack-text/src/emoji.ts

@@ -54,11 +54,13 @@ export function slackEmojiCharacter(name: string): string | undefined {
     return entry.unicode;
   }
   const modifier = SKIN_TONE_MODIFIERS[Number(toned[2]) - 2]!;
+  // A multi-person emoji repeats the tone for each person; the variant
+  // Slack's single suffix names is the one carrying that tone and no other.
   const skin = entry.skins?.find((s) => {
     const modifiers = s.hexcode
       .split("-")
       .filter((h) => SKIN_TONE_MODIFIERS.includes(h));
-    return modifiers.length === 1 && modifiers[0] === modifier;
+    return modifiers.length > 0 && modifiers.every((h) => h === modifier);
   });
   return skin?.unicode ?? entry.unicode;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vellumai/assistant",
-  "version": "0.11.10-dev.202609092113.0fb45bc",
+  "version": "0.11.10-dev.202609092213.434c99d",
   "license": "MIT",
   "type": "module",
   "exports": {

package/src/__tests__/channel-guardian.test.ts

@@ -38,6 +38,7 @@ const telegramDeliverCalls: Array<{
 mock.module("../messaging/providers/telegram-bot/send.js", () => ({
   sendTelegramReply: async (chatId: string, text: string) => {
     telegramDeliverCalls.push({ chatId, text });
+    return { messageIds: [] };
   },
   sendTelegramAttachments: async () => ({
     allFailed: false,

package/src/__tests__/discord-callback-round-trip.test.ts

@@ -19,13 +19,18 @@ const sent: Array<{ channelId: string; text: string }> = [];
 // need. `mock.module` replaces the module wholesale, so a partial stub breaks
 // the transport's import of any export it omits, and would break again the
 // next time `send.ts` grows one.
+const { acknowledgedSend } =
+  await import("../messaging/providers/send-result.js");
 const actualSend = await import("../messaging/providers/discord/send.js");
 
+const actualDiscordSend =
+  await import("../messaging/providers/discord/send.js");
 mock.module("../messaging/providers/discord/send.js", () => ({
+  ...actualDiscordSend,
   ...actualSend,
   sendDiscordReply: async (target: { channelId: string }, text: string) => {
     sent.push({ channelId: target.channelId, text });
-    return { messageId: "1401234567890123456" };
+    return acknowledgedSend(["1401234567890123456"]);
   },
 }));
 

package/src/__tests__/messaging-send-tool.test.ts

@@ -42,6 +42,17 @@ function makeProvider(id: string, displayName: string): MessagingProvider {
 const phoneProvider = makeProvider("phone", "Phone");
 const telegramProvider = makeProvider("telegram", "Telegram");
 const outlookProvider = makeProvider("outlook", "Outlook");
+// Slack's provider threads exactly where it is told and reports that thread
+// on the result; Telegram's ignores a requested thread and reports none.
+const slackProvider: MessagingProvider = {
+  ...makeProvider("slack", "Slack"),
+  sendMessage: async (_connection, conversationId, _text, options) => ({
+    id: "1700000000.000100",
+    timestamp: 123,
+    conversationId,
+    ...(options?.threadId ? { threadId: options.threadId } : {}),
+  }),
+};
 let provider: MessagingProvider = phoneProvider;
 
 let connection: OAuthConnection | undefined = undefined;
@@ -125,6 +136,13 @@ mock.module("../notifications/conversation-pairing.js", () => ({
   resolveProactiveHomeConversation: resolveProactiveHomeConversationMock,
 }));
 
+mock.module("../persistence/external-conversation-store.js", () => ({
+  normalizeExternalThreadId: (value: string | null | undefined) => {
+    const trimmed = value?.trim();
+    return trimmed ? trimmed : null;
+  },
+}));
+
 mock.module("../notifications/delivered-post-record.js", () => ({
   recordDeliveredChannelPost: recordDeliveredChannelPostMock,
 }));
@@ -349,6 +367,136 @@ describe("messaging-send tool", () => {
     expect(recordDeliveredChannelPostMock).not.toHaveBeenCalled();
   });
 
+  test("records nothing when the post landed in the turn's own thread, even though the home is elsewhere", async () => {
+    // A Slack agent-style DM keys one conversation per thread. Its home
+    // resolves to the chat's notification conversation, so the home test
+    // alone would record this send as a cross-post away from the thread it
+    // was made in. The turn's own snapshot (channel, chat, thread) decides
+    // instead, against the thread the provider says it delivered into.
+    provider = slackProvider;
+
+    await run(
+      {
+        platform: "slack",
+        conversation_id: "D0123456789",
+        thread_id: "1700000000.000001",
+        text: "hello",
+      },
+      {
+        workingDir: "/tmp",
+        conversationId: "conv-A",
+        assistantId: "ast-1",
+        trustClass: "guardian" as const,
+        executionChannel: "slack",
+        requesterChatId: "D0123456789",
+        sourceThreadId: "1700000000.000001",
+      },
+    );
+
+    expect(resolveProactiveHomeConversationMock).not.toHaveBeenCalled();
+    expect(recordDeliveredChannelPostMock).not.toHaveBeenCalled();
+  });
+
+  test("records a send into the turn's chat but a different thread as a cross-post", async () => {
+    provider = slackProvider;
+
+    await run(
+      {
+        platform: "slack",
+        conversation_id: "D0123456789",
+        thread_id: "1700000000.000002",
+        text: "hello",
+      },
+      {
+        workingDir: "/tmp",
+        conversationId: "conv-A",
+        assistantId: "ast-1",
+        trustClass: "guardian" as const,
+        executionChannel: "slack",
+        requesterChatId: "D0123456789",
+        sourceThreadId: "1700000000.000001",
+      },
+    );
+
+    expect(resolveProactiveHomeConversationMock).toHaveBeenCalledTimes(1);
+    expect(recordDeliveredChannelPostMock).toHaveBeenCalledTimes(1);
+  });
+
+  test("a thread-less delivery never matches a turn that arrived in a thread", async () => {
+    provider = slackProvider;
+
+    await run(
+      {
+        platform: "slack",
+        conversation_id: "D0123456789",
+        text: "hello",
+      },
+      {
+        workingDir: "/tmp",
+        conversationId: "conv-A",
+        assistantId: "ast-1",
+        trustClass: "guardian" as const,
+        executionChannel: "slack",
+        requesterChatId: "D0123456789",
+        sourceThreadId: "1700000000.000001",
+      },
+    );
+
+    expect(recordDeliveredChannelPostMock).toHaveBeenCalledTimes(1);
+  });
+
+  test("decides by where the provider delivered, not by the thread requested", async () => {
+    // Telegram's provider ignores a requested thread and reports none, so a
+    // turn that arrived in a topic and asked for that topic still gets a
+    // post in the thread-less chat; that post is recorded, not suppressed.
+    provider = telegramProvider;
+
+    await run(
+      {
+        platform: "telegram",
+        conversation_id: "123456789",
+        thread_id: "777",
+        text: "hello",
+      },
+      {
+        workingDir: "/tmp",
+        conversationId: "conv-A",
+        assistantId: "ast-1",
+        trustClass: "guardian" as const,
+        executionChannel: "telegram",
+        requesterChatId: "123456789",
+        sourceThreadId: "777",
+      },
+    );
+
+    expect(recordDeliveredChannelPostMock).toHaveBeenCalledTimes(1);
+  });
+
+  test("a turn that arrived through no channel falls back to the home comparison", async () => {
+    provider = slackProvider;
+    resolveProactiveHomeConversationMock.mockImplementation(async () => ({
+      conversationId: "conv-A",
+      createdNewConversation: false,
+    }));
+
+    await run(
+      {
+        platform: "slack",
+        conversation_id: "D0123456789",
+        text: "hello",
+      },
+      {
+        workingDir: "/tmp",
+        conversationId: "conv-A",
+        assistantId: "ast-1",
+        trustClass: "guardian" as const,
+      },
+    );
+
+    expect(resolveProactiveHomeConversationMock).toHaveBeenCalledTimes(1);
+    expect(recordDeliveredChannelPostMock).not.toHaveBeenCalled();
+  });
+
   test("records nothing for a provider that is not a channel", async () => {
     provider = outlookProvider;
     connection = {

package/src/__tests__/notification-discord-adapter.test.ts

@@ -29,9 +29,14 @@ mock.module("../messaging/providers/discord/api.js", () => ({
   },
 }));
 
+const { acknowledgedSend } =
+  await import("../messaging/providers/send-result.js");
 const actualSend = await import("../messaging/providers/discord/send.js");
+const actualDiscordSend =
+  await import("../messaging/providers/discord/send.js");
 mock.module("../messaging/providers/discord/send.js", () => ({
-  DiscordPartialSendError: actualSend.DiscordPartialSendError,
+  ...actualDiscordSend,
+  ...actualSend,
   sendDiscordReply: async (
     target: { channelId: string },
     text: string,
@@ -48,7 +53,7 @@ mock.module("../messaging/providers/discord/send.js", () => ({
         : new Error("simulated component rejection");
     }
     sendCalls.push({ channelId: target.channelId, text, approval });
-    return { lastMessageId: String(2000 + sendCalls.length) };
+    return acknowledgedSend([String(2000 + sendCalls.length)]);
   },
   editDiscordMessage: async (
     target: { channelId: string },

package/src/__tests__/notification-slack-adapter.test.ts

@@ -18,7 +18,9 @@ const sendCalls: Array<{
 }> = [];
 
 const actualSend = await import("../messaging/providers/slack/send.js");
+const actualSlackSend = await import("../messaging/providers/slack/send.js");
 mock.module("../messaging/providers/slack/send.js", () => ({
+  ...actualSlackSend,
   ...actualSend,
   sendSlackReply: async (
     chatId: string,

package/src/__tests__/notification-telegram-adapter.test.ts

@@ -22,7 +22,12 @@ const editCalls: Array<{
 /** When set, editTelegramMessage rejects with this message. */
 let editFailure: string | undefined;
 
+const { acknowledgedSend } =
+  await import("../messaging/providers/send-result.js");
+const actualTelegramSend =
+  await import("../messaging/providers/telegram-bot/send.js");
 mock.module("../messaging/providers/telegram-bot/send.js", () => ({
+  ...actualTelegramSend,
   sendTelegramReply: async (
     chatId: string,
     text: string,
@@ -36,9 +41,9 @@ mock.module("../messaging/providers/telegram-bot/send.js", () => ({
       text,
       approval: approval as (typeof sendCalls)[0]["approval"],
     });
-    // Mirror the real send result: the id of the sent message, which the
-    // adapter surfaces so the delivery row can address the card later.
-    return { lastMessageId: String(1000 + sendCalls.length) };
+    // The real send result: the id of the sent message, which the adapter
+    // surfaces so the delivery row can address the card later.
+    return acknowledgedSend([String(1000 + sendCalls.length)]);
   },
   sendTelegramAttachments: async () => ({
     allFailed: false,

package/src/__tests__/verification-outbound-delivery.test.ts

@@ -33,7 +33,9 @@ mock.module("../config/env.js", () => ({
 const deliveries: Array<{ transport: string; to: string; text: string }> = [];
 
 const realSlackSend = await import("../messaging/providers/slack/send.js");
+const actualSlackSend = await import("../messaging/providers/slack/send.js");
 mock.module("../messaging/providers/slack/send.js", () => ({
+  ...actualSlackSend,
   ...realSlackSend,
   sendSlackReply: async (chatId: string, text: string) => {
     deliveries.push({ transport: "slack", to: chatId, text });
@@ -47,7 +49,7 @@ mock.module("../messaging/providers/telegram-bot/send.js", () => ({
   ...realTelegramSend,
   sendTelegramReply: async (chatId: string, text: string) => {
     deliveries.push({ transport: "telegram", to: chatId, text });
-    return {};
+    return { messageIds: [] };
   },
 }));
 
@@ -59,11 +61,14 @@ mock.module("../messaging/providers/discord/api.js", () => ({
 }));
 
 const realDiscordSend = await import("../messaging/providers/discord/send.js");
+const actualDiscordSend =
+  await import("../messaging/providers/discord/send.js");
 mock.module("../messaging/providers/discord/send.js", () => ({
+  ...actualDiscordSend,
   ...realDiscordSend,
   sendDiscordReply: async (target: { channelId: string }, text: string) => {
     deliveries.push({ transport: "discord", to: target.channelId, text });
-    return {};
+    return { messageIds: [] };
   },
 }));
 

package/src/calls/spoken-reply-rules.ts

@@ -0,0 +1,20 @@
+/**
+ * Model-facing rules for any reply that is synthesized to speech. Shared by
+ * the phone-call control prompt (voice-session-bridge.ts) and the in-app
+ * live-voice control prompt (live-voice/live-voice-session.ts) so the two
+ * surfaces cannot drift on what a spoken reply is allowed to look like.
+ *
+ * Both rules describe the delivery path, not the surface: the caller hears
+ * the text, and sanitizeForTts (tts-text-sanitizer.ts) strips markdown
+ * syntax but keeps the content, so a five-bullet answer is still five
+ * bullets of audio with the dashes removed. The length rule is what keeps
+ * that answer from being produced in the first place.
+ */
+
+/** One to three spoken sentences; the caller is listening, not reading. */
+export const SPOKEN_REPLY_LENGTH_RULE =
+  "Keep each reply to one to three spoken sentences. The caller is listening, not reading: lead with the answer, say it in the fewest words that are still complete, and stop. No preamble, no recap of the question, no closing offer of more.";
+
+/** Plain conversational text only; the text goes straight to a TTS engine. */
+export const SPOKEN_REPLY_PLAIN_TEXT_RULE =
+  "Your text is sent directly to a text-to-speech engine. Never use markdown formatting (asterisks, headers, backticks, links), bulleted or numbered lists, or emojis. Write plain conversational text only; if something is naturally a list, say it as one sentence.";

package/src/calls/voice-session-bridge.ts

@@ -58,6 +58,10 @@ import { sensitiveToolReach } from "../tools/tool-approval-handler.js";
 import { createAbortReason } from "../util/abort-reasons.js";
 import { getLogger } from "../util/logger.js";
 import { truncate } from "../util/truncate.js";
+import {
+  SPOKEN_REPLY_LENGTH_RULE,
+  SPOKEN_REPLY_PLAIN_TEXT_RULE,
+} from "./spoken-reply-rules.js";
 import {
   CALL_OPENING_MARKER,
   CALL_VERIFICATION_COMPLETE_MARKER,
@@ -630,7 +634,7 @@ function buildVoiceCallControlPrompt(opts: {
   lines.push(
     "CALL PROTOCOL RULES:",
     disclosureRule,
-    "1. Be concise — keep responses to 1-3 sentences. Phone conversations should be brief and natural.",
+    `1. ${SPOKEN_REPLY_LENGTH_RULE}`,
     ...(opts.isCallerGuardian
       ? [
           "2. You are speaking directly with your guardian (your user). Do NOT use [ASK_GUARDIAN:]. If you need permission, information, or confirmation, ask them directly in the conversation. They can answer you right now.",
@@ -691,7 +695,7 @@ function buildVoiceCallControlPrompt(opts: {
   lines.push(
     "9. After the opening greeting turn, treat the Task field as background context only — do not re-execute its instructions on subsequent turns.",
     '10. Do not make up information. If you are unsure, use [ASK_GUARDIAN: your question] to consult your guardian. For tool permission requests, use [ASK_GUARDIAN_APPROVAL: {"question":"...","toolName":"...","input":{...}}].',
-    `11. Your text is sent directly to a text-to-speech engine. Never use markdown formatting (asterisks, headers, backticks, links) or emojis in your spoken responses. Write plain conversational text only. Protocol markers like ${opts.isCallerGuardian ? "[END_CALL]" : "[ASK_GUARDIAN: ...] and [END_CALL]"} are not spoken text and should still be used normally.`,
+    `11. ${SPOKEN_REPLY_PLAIN_TEXT_RULE} Protocol markers like ${opts.isCallerGuardian ? "[END_CALL]" : "[ASK_GUARDIAN: ...] and [END_CALL]"} are not spoken text and should still be used normally.`,
     `12. Speak the caller's language: reply in the language of the caller's most recent actual speech, and follow them if they switch languages mid-call. Synthetic user turns (parenthetical markers like the call-connected and verification-completed notices) are not caller speech and never set the language. Before the caller has spoken, such as on the opening greeting turn, ${preSpeechLanguageRuleFragment(config.services.stt.language, sttCatalogKeyForRole(config.services.stt, "telephony"))}.`,
     `13. ${PHONE_NO_SETUP_FLOWS_RULE}`,
   );

package/src/calls/voice-triage-escalate.ts

@@ -334,7 +334,7 @@ export function createFrontDoorStreamGate(
  * just above it.
  */
 export const ESCALATION_CONTINUATION_CONTENT =
-  "(You just told the caller you needed a moment to think. Now give them your full, careful answer to their previous question — do not repeat the holding phrase.)";
+  "(You just told the caller you needed a moment to think. Now answer their previous question out loud. Cover what they asked, but as a few spoken sentences rather than a written write-up: they are listening, not reading. Do not repeat the holding phrase.)";
 
 /**
  * Compact, registry-derived digest of the tools the ESCALATED leg can use.

package/src/cli/commands/__tests__/conversations-slack.test.ts

@@ -109,7 +109,10 @@ mock.module("../../../ipc/gateway-client.js", () => ({
   }),
 }));
 
+const actualSlackSend =
+  await import("../../../messaging/providers/slack/send.js");
 mock.module("../../../messaging/providers/slack/send.js", () => ({
+  ...actualSlackSend,
   updateSlackMessage: async () => ({ ok: true, ts: "ts" }),
   sendSlackReply: async (
     chatId: string,

package/src/config/bundled-skills/messaging/tools/messaging-send.ts

@@ -20,6 +20,7 @@ import { resolveProactiveHomeConversation } from "../../../../notifications/conv
 import { recordDeliveredChannelPost } from "../../../../notifications/delivered-post-record.js";
 import { getConversation } from "../../../../persistence/conversation-crud.js";
 import { syncMessageToDisk } from "../../../../persistence/conversation-disk-view.js";
+import { normalizeExternalThreadId } from "../../../../persistence/external-conversation-store.js";
 import type {
   ToolContext,
   ToolExecutionResult,
@@ -64,26 +65,48 @@ const ATTACHMENT_CAPABLE_PLATFORMS = new Set(["gmail", "outlook"]);
  * envelope and in `channel_outbound_posts` like every other post the daemon
  * makes.
  *
- * A send made from inside the home conversation itself writes no row: its
- * tool call and result already sit in that conversation's history, and a
- * second assistant row beside the tool pair would break history repair. The
- * post is then in the outbound index only through no path, which is the
- * same class as a raw API send and is deferred with it.
+ * A send into the sending turn's own chat writes no row: its tool call and
+ * result already sit in that conversation's history, and a second assistant
+ * row beside the tool pair would break history repair. Whether the send is
+ * "its own" is decided by the delivered target against the turn, not by the
+ * home: the turn arrived on a channel, in a chat, in a thread (the turn-local
+ * snapshot on the tool context), and a post the provider delivered to exactly
+ * that place is a same-conversation send even when the chat's home resolves
+ * elsewhere, as it does for a thread-scoped chat whose home is the chat's
+ * notification conversation. The delivered thread is the one the provider
+ * reports, not the one requested: a provider that ignores the request lands
+ * the post in the thread-less chat, and the record must say so. The home
+ * comparison stays as the second test, for a sender that arrived through no
+ * channel but is the home. The post is then in the outbound index only
+ * through no path, which is the same class as a raw API send and is deferred
+ * with it.
  *
  * Failures here never fail the send: the message is already out.
  */
 async function recordSentChannelPost(params: {
   providerId: string;
   externalChatId: string;
+  /** The thread the provider delivered into, as it reported it. */
+  deliveredThreadId: string | undefined;
   text: string;
   providerMessageId: string;
-  senderConversationId: string;
+  sender: ToolContext;
 }): Promise<void> {
-  const { providerId, externalChatId } = params;
+  const { providerId, externalChatId, sender } = params;
   if (!isChannelId(providerId) || !params.providerMessageId) {
     return;
   }
   try {
+    if (
+      isSendIntoOwnChat(
+        sender,
+        providerId,
+        externalChatId,
+        params.deliveredThreadId,
+      )
+    ) {
+      return;
+    }
     const home = await resolveProactiveHomeConversation({
       sourceChannel: providerId,
       externalChatId,
@@ -91,7 +114,7 @@ async function recordSentChannelPost(params: {
       conversationType: "background",
       title: `Messages to ${externalChatId}`,
     });
-    if (home.conversationId === params.senderConversationId) {
+    if (home.conversationId === sender.conversationId) {
       return;
     }
     const recorded = await recordDeliveredChannelPost({
@@ -100,7 +123,7 @@ async function recordSentChannelPost(params: {
       externalChatId,
       text: params.text,
       providerMessageId: params.providerMessageId,
-      crossPostedFrom: params.senderConversationId,
+      crossPostedFrom: sender.conversationId,
     });
     const homeConversation = getConversation(home.conversationId);
     if (homeConversation) {
@@ -118,6 +141,32 @@ async function recordSentChannelPost(params: {
   }
 }
 
+/**
+ * True when the delivered chat and thread are the ones the sending turn
+ * arrived in. Reads the turn-local snapshot the tool context carries
+ * (`executionChannel`, `requesterChatId`, `sourceThreadId`), never the live
+ * binding, which a concurrent inbound can rewrite while this call runs.
+ * Thread ids compare in the binding store's normalized form, so an absent
+ * thread on both sides matches and a thread-less delivery never matches a
+ * turn that arrived in a thread.
+ */
+function isSendIntoOwnChat(
+  sender: ToolContext,
+  channel: string,
+  externalChatId: string,
+  deliveredThreadId: string | undefined,
+): boolean {
+  if (!sender.executionChannel || !sender.requesterChatId) {
+    return false;
+  }
+  return (
+    sender.executionChannel === channel &&
+    sender.requesterChatId === externalChatId &&
+    normalizeExternalThreadId(sender.sourceThreadId) ===
+      normalizeExternalThreadId(deliveredThreadId)
+  );
+}
+
 export async function run(
   input: Record<string, unknown>,
   context: ToolContext,
@@ -372,9 +421,10 @@ export async function run(
     await recordSentChannelPost({
       providerId: provider.id,
       externalChatId: conversationId,
+      deliveredThreadId: result.threadId,
       text,
       providerMessageId: result.id,
-      senderConversationId: context.conversationId,
+      sender: context,
     });
 
     return ok(`Message sent (ID: ${result.id}${threadSuffix}).`);