feat: add configurable truncation direction for notification messages

Messages exceeding service limits can now be truncated from the beginning
or end, controlled via `truncateFrom` ("end" default, "start" keeps the
conclusion). Configurable globally and per-service, with `...` indicator.

Author: Slyrian

README.md

@@ -27,6 +27,7 @@ In long-running development tasks or deep research sessions, it's common to swit
 - ✅ **Privacy & Control**: Completely opt-in; no notifications are sent until you enable and configure a service.
 - ✅ **Event Filtering**: Selectively enable or disable notifications for specific event types.
 - ✅ **Rich Content**: Notifications include the actual assistant response text for better context.
+- ✅ **Truncation Direction**: Choose whether to keep the beginning or end of long messages when they exceed service limits.
 
 ## Installation
 
@@ -117,7 +118,8 @@ Create your `.everynotify.json` with the tokens for the services you want to use
     "error": true,
     "permission": false,
     "question": true
-  }
+  },
+  "truncateFrom": "end"
 }
 ```
 
@@ -135,6 +137,41 @@ You can control which events trigger notifications by adding an `events` block t
 | `permission`        | opencode is waiting for you to grant permission for a tool or file access. |
 | `question`          | The `question` tool was used to ask you for clarification.                 |
 
+### Message Truncation
+
+Each notification service has a maximum message length (e.g., Pushover: 1024 chars, Discord: 2000 chars). When a message exceeds the limit, EveryNotify truncates it and adds `...` as an indicator.
+
+The `truncateFrom` option controls which part of the message is kept:
+
+| Value     | Behavior                           | Best For                                      |
+| --------- | ---------------------------------- | --------------------------------------------- |
+| `"end"`   | Keep beginning, trim end (default) | When the start of the message has the context |
+| `"start"` | Keep end, trim beginning           | When the conclusion/result at the end matters |
+
+**Global setting** applies to all services:
+
+```json
+{
+  "truncateFrom": "start"
+}
+```
+
+**Per-service override** — for example, keep message endings on Pushover but beginnings on Slack:
+
+```json
+{
+  "truncateFrom": "end",
+  "pushover": {
+    "enabled": true,
+    "token": "...",
+    "userKey": "...",
+    "truncateFrom": "start"
+  }
+}
+```
+
+Service-level `truncateFrom` takes priority over the global setting.
+
 ### Rich Message Content
 
 EveryNotify provides rich context in its notifications by extracting the assistant's last response. Instead of generic "Task completed" messages, you receive the actual summary or answer provided by opencode.
@@ -227,6 +264,10 @@ For Pushover users, you can customize the `priority` level:
 - `1`: High priority (bypasses quiet hours)
 - `2`: Emergency priority (requires acknowledgment)
 
+### Message Truncation Direction
+
+See [Message Truncation](#message-truncation) under Configuration Options for details on the `truncateFrom` setting. This is especially useful for services with tight message limits like Pushover (1024 chars), where the end of a message often contains the most important information (the result or conclusion).
+
 ### Session Enrichment
 
 EveryNotify automatically calculates the time elapsed since the first user message in a session. This duration is included in the notification text to give you context on how long the task took to complete.

src/__tests__/dispatcher.test.ts

@@ -77,6 +77,14 @@ describe("dispatcher", () => {
     log: {
       enabled: false,
     },
+    events: {
+      complete: true,
+      subagent_complete: true,
+      error: true,
+      permission: true,
+      question: true,
+    },
+    truncateFrom: "end",
   });
 
   const createTestPayload = (
@@ -108,24 +116,23 @@ describe("dispatcher", () => {
     expect(mockSlackSend).toHaveBeenCalledTimes(1);
     expect(mockDiscordSend).toHaveBeenCalledTimes(1);
 
-    // Verify each service received correct config and payload
     expect(mockPushoverSend).toHaveBeenCalledWith(
-      config.pushover,
+      { ...config.pushover, truncateFrom: "end" },
       payload,
-      expect.any(Object), // AbortSignal
+      expect.any(Object),
     );
     expect(mockTelegramSend).toHaveBeenCalledWith(
-      config.telegram,
+      { ...config.telegram, truncateFrom: "end" },
       payload,
       expect.any(Object),
     );
     expect(mockSlackSend).toHaveBeenCalledWith(
-      config.slack,
+      { ...config.slack, truncateFrom: "end" },
       payload,
       expect.any(Object),
     );
     expect(mockDiscordSend).toHaveBeenCalledWith(
-      config.discord,
+      { ...config.discord, truncateFrom: "end" },
       payload,
       expect.any(Object),
     );
@@ -291,39 +298,31 @@ describe("dispatcher", () => {
     expect(mockDiscordSend).toHaveBeenCalledTimes(0);
   });
 
-  test("truncate function works correctly", () => {
-    // Text shorter than limit — no truncation
+  test("truncate from end (default) keeps beginning of text", () => {
     expect(truncate("Hello", 10)).toBe("Hello");
-
-    // Text exactly at limit — no truncation
     expect(truncate("Hello", 5)).toBe("Hello");
 
-    // Text over limit — truncated with suffix
-    const longText = "A".repeat(100);
-    const truncated = truncate(longText, 50);
-    expect(truncated.length).toBe(50);
-    expect(truncated.endsWith("… [truncated]")).toBe(true);
+    const longText = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
+    const result = truncate(longText, 10);
+    expect(result.length).toBe(10);
+    expect(result).toBe("ABCDEFG...");
+  });
+
+  test("truncate from start keeps end of text", () => {
+    expect(truncate("Hello", 10, "start")).toBe("Hello");
+    expect(truncate("Hello", 5, "start")).toBe("Hello");
 
-    // Verify truncation preserves correct prefix length
-    const suffix = "… [truncated]";
-    const expectedPrefix = "A".repeat(50 - suffix.length);
-    expect(truncated).toBe(expectedPrefix + suffix);
+    const longText = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
+    const result = truncate(longText, 10, "start");
+    expect(result.length).toBe(10);
+    expect(result).toBe("...TUVWXYZ");
   });
 
   test("truncate handles boundary cases", () => {
-    // Empty string
     expect(truncate("", 10)).toBe("");
-
-    // maxLength = 0
-    expect(truncate("Hello", 0)).toBe("… [truncated]");
-
-    // maxLength < suffix length
-    expect(truncate("Hello", 5)).toBe("Hello");
-    expect(truncate("Hello World", 5)).toBe("… [truncated]");
-
-    // maxLength = suffix length (text longer than maxLength)
-    const suffix = "… [truncated]";
-    const longText = "A".repeat(100);
-    expect(truncate(longText, suffix.length)).toBe(suffix);
+    expect(truncate("Hello World", 0)).toBe("...");
+    expect(truncate("Hello World", 3)).toBe("...");
+    expect(truncate("Hello World", 4)).toBe("H...");
+    expect(truncate("Hello World", 4, "start")).toBe("...d");
   });
 });

src/__tests__/services/discord.test.ts

@@ -103,7 +103,6 @@ describe("Discord Service", () => {
       const [, options] = fetchSpy.mock.calls[0];
       const body = JSON.parse(options?.body as string);
       expect(body.content.length).toBeLessThanOrEqual(2000);
-      expect(body.content).toContain("… [truncated]");
     });
 
     it("should pass AbortSignal to fetch for timeout control", async () => {

src/__tests__/services/pushover.test.ts

@@ -102,7 +102,6 @@ describe("Pushover Service", () => {
       encodedMessage.replace(/\+/g, " "),
     );
     expect(decodedMessage.length).toBeLessThanOrEqual(1024);
-    expect(decodedMessage).toContain("… [truncated]");
   });
 
   it("truncates title at 250 characters", async () => {
@@ -123,7 +122,6 @@ describe("Pushover Service", () => {
     const encodedTitle = titleMatch![1];
     const decodedTitle = decodeURIComponent(encodedTitle.replace(/\+/g, " "));
     expect(decodedTitle.length).toBeLessThanOrEqual(250);
-    expect(decodedTitle).toContain("… [truncated]");
   });
 
   it("passes AbortSignal to fetch for timeout control", async () => {

src/__tests__/services/slack.test.ts

@@ -175,7 +175,6 @@ describe("Slack Service", () => {
     const body = options?.body as string;
     const parsed = JSON.parse(body);
     expect(parsed.text.length).toBeLessThanOrEqual(40000);
-    expect(parsed.text).toContain("… [truncated]");
   });
 
   it("passes AbortSignal to fetch", async () => {

src/__tests__/services/telegram.test.ts

@@ -102,7 +102,6 @@ describe("Telegram Service", () => {
     const body = JSON.parse(options.body);
 
     expect(body.text.length).toBeLessThanOrEqual(4096);
-    expect(body.text).toContain("… [truncated]");
   });
 
   it("passes AbortSignal to fetch for timeout control", async () => {
@@ -172,7 +171,6 @@ describe("Telegram Service", () => {
     const body = JSON.parse(options.body);
 
     expect(body.text.length).toBeLessThanOrEqual(4096);
-    expect(body.text).toContain("… [truncated]");
   });
 
   it("uses correct chat_id format for group chats", async () => {

src/config.ts

@@ -48,6 +48,7 @@ export const DEFAULT_CONFIG: EverynotifyConfig = {
     permission: true,
     question: true,
   },
+  truncateFrom: "end",
 };
 
 /**
@@ -97,6 +98,9 @@ function deepMerge(
   if (source.events) {
     result.events = { ...result.events, ...source.events };
   }
+  if (source.truncateFrom !== undefined) {
+    result.truncateFrom = source.truncateFrom;
+  }
 
   return result;
 }

src/dispatcher.ts

@@ -11,27 +11,30 @@ import type {
   EverynotifyConfig,
   NotificationPayload,
   EventType,
+  TruncationMode,
 } from "./types";
 import type { Logger } from "./logger";
 import { send as pushoverSend } from "./services/pushover";
 import { send as telegramSend } from "./services/telegram";
 import { send as slackSend } from "./services/slack";
 import { send as discordSend } from "./services/discord";
 
-/**
- * Truncate text to max length, appending "… [truncated]" if over limit
- * Shared utility function used by all services
- */
-export function truncate(text: string, maxLength: number): string {
+export function truncate(
+  text: string,
+  maxLength: number,
+  from: TruncationMode = "end",
+): string {
   if (text.length <= maxLength) {
     return text;
   }
-  const suffix = "… [truncated]";
-  // If maxLength is too small for suffix, return just the suffix
-  if (maxLength <= suffix.length) {
-    return suffix;
+  const indicator = "...";
+  if (maxLength <= indicator.length) {
+    return indicator;
   }
-  return text.slice(0, maxLength - suffix.length) + suffix;
+  if (from === "start") {
+    return indicator + text.slice(text.length - (maxLength - indicator.length));
+  }
+  return text.slice(0, maxLength - indicator.length) + indicator;
 }
 
 /**
@@ -68,35 +71,49 @@ export function createDispatcher(
   // Build array of enabled services
   const services: ServiceDescriptor[] = [];
 
+  const globalTruncateFrom = config.truncateFrom ?? "end";
+
   if (config.pushover.enabled) {
     services.push({
       name: "Pushover",
       send: pushoverSend,
-      config: config.pushover,
+      config: {
+        ...config.pushover,
+        truncateFrom: config.pushover.truncateFrom ?? globalTruncateFrom,
+      },
     });
   }
 
   if (config.telegram.enabled) {
     services.push({
       name: "Telegram",
       send: telegramSend,
-      config: config.telegram,
+      config: {
+        ...config.telegram,
+        truncateFrom: config.telegram.truncateFrom ?? globalTruncateFrom,
+      },
     });
   }
 
   if (config.slack.enabled) {
     services.push({
       name: "Slack",
       send: slackSend,
-      config: config.slack,
+      config: {
+        ...config.slack,
+        truncateFrom: config.slack.truncateFrom ?? globalTruncateFrom,
+      },
     });
   }
 
   if (config.discord.enabled) {
     services.push({
       name: "Discord",
       send: discordSend,
-      config: config.discord,
+      config: {
+        ...config.discord,
+        truncateFrom: config.discord.truncateFrom ?? globalTruncateFrom,
+      },
     });
   }
 

src/services/discord.ts

@@ -30,7 +30,11 @@ export async function send(
   payload: NotificationPayload,
   signal: AbortSignal,
 ): Promise<void> {
-  const content = truncate(formatDiscordMessage(payload), 2000);
+  const content = truncate(
+    formatDiscordMessage(payload),
+    2000,
+    config.truncateFrom,
+  );
 
   const response = await fetch(config.webhookUrl, {
     method: "POST",

src/services/pushover.ts

@@ -25,8 +25,8 @@ export async function send(
   const body = new URLSearchParams({
     token: config.token,
     user: config.userKey,
-    message: truncate(payload.message, 1024),
-    title: truncate(payload.title, 250),
+    message: truncate(payload.message, 1024, config.truncateFrom),
+    title: truncate(payload.title, 250, config.truncateFrom),
     priority: String(config.priority ?? 0),
   });