@calltelemetry/openclaw-linear 0.7.1 → 0.8.0

package/src/infra/notify.test.ts

@@ -3,6 +3,7 @@ import {
   createNoopNotifier,
   createNotifierFromConfig,
   formatMessage,
+  formatRichMessage,
   sendToTarget,
   parseNotificationsConfig,
   type NotifyKind,
@@ -23,24 +24,24 @@ describe("formatMessage", () => {
 
   it("formats dispatch message", () => {
     const msg = formatMessage("dispatch", basePayload);
-    expect(msg).toBe("API-42 dispatched — Fix auth");
+    expect(msg).toBe("API-42 started — Fix auth");
   });
 
   it("formats working message with attempt", () => {
     const msg = formatMessage("working", { ...basePayload, attempt: 1 });
-    expect(msg).toContain("worker started");
-    expect(msg).toContain("attempt 1");
+    expect(msg).toContain("working on it");
+    expect(msg).toContain("attempt 2"); // 1-based for humans
   });
 
   it("formats auditing message", () => {
     const msg = formatMessage("auditing", basePayload);
-    expect(msg).toContain("audit in progress");
+    expect(msg).toContain("checking the work");
   });
 
   it("formats audit_pass message", () => {
     const msg = formatMessage("audit_pass", basePayload);
-    expect(msg).toContain("passed audit");
-    expect(msg).toContain("PR ready");
+    expect(msg).toContain("done!");
+    expect(msg).toContain("Ready for review");
   });
 
   it("formats audit_fail message with gaps", () => {
@@ -49,8 +50,8 @@ describe("formatMessage", () => {
       attempt: 1,
       verdict: { pass: false, gaps: ["no tests", "missing validation"] },
     });
-    expect(msg).toContain("failed audit");
-    expect(msg).toContain("attempt 1");
+    expect(msg).toContain("needs more work");
+    expect(msg).toContain("attempt 2"); // 1-based for humans
     expect(msg).toContain("no tests");
     expect(msg).toContain("missing validation");
   });
@@ -67,10 +68,10 @@ describe("formatMessage", () => {
   it("formats escalation message with reason", () => {
     const msg = formatMessage("escalation", {
       ...basePayload,
-      reason: "audit failed 3x",
+      attempt: 2,
     });
-    expect(msg).toContain("needs human review");
-    expect(msg).toContain("audit failed 3x");
+    expect(msg).toContain("needs your help");
+    expect(msg).toContain("3 tries"); // 1-based
   });
 
   it("formats stuck message", () => {
@@ -86,11 +87,11 @@ describe("formatMessage", () => {
     const msg = formatMessage("watchdog_kill", {
       ...basePayload,
       attempt: 0,
-      reason: "no I/O for 120s",
+      reason: "no activity for 120s",
     });
-    expect(msg).toContain("killed by watchdog");
-    expect(msg).toContain("no I/O for 120s");
-    expect(msg).toContain("Retrying (attempt 0)");
+    expect(msg).toContain("timed out");
+    expect(msg).toContain("no activity for 120s");
+    expect(msg).toContain("Retrying (attempt 1)"); // 1-based
   });
 
   it("formats watchdog_kill without attempt", () => {
@@ -325,7 +326,7 @@ describe("createNotifierFromConfig", () => {
     expect(runtime.channel.telegram.sendMessageTelegram).toHaveBeenCalledOnce();
     expect(runtime.channel.telegram.sendMessageTelegram).toHaveBeenCalledWith(
       "-100388",
-      expect.stringContaining("worker started"),
+      expect.stringContaining("working on it"),
       { silent: true },
     );
   });
@@ -402,6 +403,144 @@ describe("createNotifierFromConfig", () => {
   });
 });
 
+// ---------------------------------------------------------------------------
+// formatRichMessage
+// ---------------------------------------------------------------------------
+
+describe("formatRichMessage", () => {
+  const basePayload: NotifyPayload = {
+    identifier: "CT-10",
+    title: "Add caching",
+    status: "dispatched",
+  };
+
+  it("returns Discord embed with correct color for dispatch (blue)", () => {
+    const msg = formatRichMessage("dispatch", basePayload);
+    expect(msg.discord?.embeds).toHaveLength(1);
+    expect(msg.discord!.embeds[0].color).toBe(0x3498db);
+  });
+
+  it("returns Discord embed with green for audit_pass", () => {
+    const msg = formatRichMessage("audit_pass", basePayload);
+    expect(msg.discord!.embeds[0].color).toBe(0x2ecc71);
+  });
+
+  it("returns Discord embed with red for audit_fail", () => {
+    const msg = formatRichMessage("audit_fail", { ...basePayload, attempt: 1, verdict: { pass: false, gaps: ["no tests"] } });
+    expect(msg.discord!.embeds[0].color).toBe(0xe74c3c);
+    expect(msg.discord!.embeds[0].fields).toEqual(
+      expect.arrayContaining([expect.objectContaining({ name: "Issues to fix", value: "no tests" })]),
+    );
+  });
+
+  it("returns Discord embed with orange for stuck", () => {
+    const msg = formatRichMessage("stuck", { ...basePayload, reason: "stale 2h" });
+    expect(msg.discord!.embeds[0].color).toBe(0xe67e22);
+  });
+
+  it("returns Telegram HTML with bold identifier", () => {
+    const msg = formatRichMessage("dispatch", basePayload);
+    expect(msg.telegram?.html).toContain("<b>CT-10</b>");
+    expect(msg.telegram?.html).toContain("<i>Add caching</i>");
+  });
+
+  it("includes plain text fallback", () => {
+    const msg = formatRichMessage("dispatch", basePayload);
+    expect(msg.text).toBe("CT-10 started — Add caching");
+  });
+});
+
+// ---------------------------------------------------------------------------
+// sendToTarget with RichMessage
+// ---------------------------------------------------------------------------
+
+describe("sendToTarget (RichMessage)", () => {
+  function mockRuntime(): any {
+    return {
+      channel: {
+        discord: { sendMessageDiscord: vi.fn(async () => {}) },
+        slack: { sendMessageSlack: vi.fn(async () => ({})) },
+        telegram: { sendMessageTelegram: vi.fn(async () => {}) },
+        signal: { sendMessageSignal: vi.fn(async () => {}) },
+      },
+    };
+  }
+
+  afterEach(() => { vi.restoreAllMocks(); });
+
+  it("passes embeds to Discord when RichMessage provided", async () => {
+    const runtime = mockRuntime();
+    const target: NotifyTarget = { channel: "discord", target: "D-1" };
+    const rich = {
+      text: "plain",
+      discord: { embeds: [{ title: "test", color: 0x3498db }] },
+    };
+    await sendToTarget(target, rich, runtime);
+    expect(runtime.channel.discord.sendMessageDiscord).toHaveBeenCalledWith(
+      "D-1", "plain", { embeds: [{ title: "test", color: 0x3498db }] },
+    );
+  });
+
+  it("passes textMode html to Telegram when RichMessage provided", async () => {
+    const runtime = mockRuntime();
+    const target: NotifyTarget = { channel: "telegram", target: "-999" };
+    const rich = {
+      text: "plain",
+      telegram: { html: "<b>CT-10</b> dispatched" },
+    };
+    await sendToTarget(target, rich, runtime);
+    expect(runtime.channel.telegram.sendMessageTelegram).toHaveBeenCalledWith(
+      "-999", "<b>CT-10</b> dispatched", { silent: true, textMode: "html" },
+    );
+  });
+});
+
+// ---------------------------------------------------------------------------
+// createNotifierFromConfig (richFormat)
+// ---------------------------------------------------------------------------
+
+describe("createNotifierFromConfig (richFormat)", () => {
+  function mockRuntime(): any {
+    return {
+      channel: {
+        discord: { sendMessageDiscord: vi.fn(async () => {}) },
+        slack: { sendMessageSlack: vi.fn(async () => ({})) },
+        telegram: { sendMessageTelegram: vi.fn(async () => {}) },
+        signal: { sendMessageSignal: vi.fn(async () => {}) },
+      },
+    };
+  }
+
+  afterEach(() => { vi.restoreAllMocks(); });
+
+  it("sends Discord embeds when richFormat is true", async () => {
+    const runtime = mockRuntime();
+    const notify = createNotifierFromConfig({
+      notifications: {
+        richFormat: true,
+        targets: [{ channel: "discord", target: "D-1" }],
+      },
+    }, runtime);
+    await notify("dispatch", { identifier: "CT-1", title: "Test", status: "dispatched" });
+    const [, , opts] = runtime.channel.discord.sendMessageDiscord.mock.calls[0];
+    expect(opts?.embeds).toBeDefined();
+    expect(opts.embeds).toHaveLength(1);
+  });
+
+  it("sends plain text when richFormat is false", async () => {
+    const runtime = mockRuntime();
+    const notify = createNotifierFromConfig({
+      notifications: {
+        richFormat: false,
+        targets: [{ channel: "discord", target: "D-1" }],
+      },
+    }, runtime);
+    await notify("dispatch", { identifier: "CT-1", title: "Test", status: "dispatched" });
+    const call = runtime.channel.discord.sendMessageDiscord.mock.calls[0];
+    expect(call).toHaveLength(2); // no third arg with embeds
+  });
+});
+
 // ---------------------------------------------------------------------------
 // createNoopNotifier
 // ---------------------------------------------------------------------------

package/src/infra/notify.ts

@@ -8,7 +8,8 @@
  * Modeled on DevClaw's notify.ts pattern — the runtime handles token resolution,
  * formatting differences (markdown vs mrkdwn), and delivery per channel.
  */
-import type { PluginRuntime } from "openclaw/plugin-sdk";
+import type { PluginRuntime, OpenClawPluginApi } from "openclaw/plugin-sdk";
+import { emitDiagnostic } from "./observability.js";
 
 // ---------------------------------------------------------------------------
 // Types
@@ -81,26 +82,27 @@ export interface RichMessage {
 
 export function formatMessage(kind: NotifyKind, payload: NotifyPayload): string {
   const id = payload.identifier;
+  const attempt = (payload.attempt ?? 0) + 1; // 1-based for humans
   switch (kind) {
     case "dispatch":
-      return `${id} dispatched — ${payload.title}`;
+      return `${id} started — ${payload.title}`;
     case "working":
-      return `${id} worker started (attempt ${payload.attempt ?? 0})`;
+      return `${id} working on it (attempt ${attempt})`;
     case "auditing":
-      return `${id} audit in progress`;
+      return `${id} checking the work...`;
     case "audit_pass":
-      return `${id} passed audit. PR ready.`;
+      return `✅ ${id} done! Ready for review.`;
     case "audit_fail": {
-      const gaps = payload.verdict?.gaps?.join(", ") ?? "unspecified";
-      return `${id} failed audit (attempt ${payload.attempt ?? 0}). Gaps: ${gaps}`;
+      const issues = payload.verdict?.gaps?.join(", ") ?? "unspecified";
+      return `${id} needs more work (attempt ${attempt}). Issues: ${issues}`;
     }
     case "escalation":
-      return `🚨 ${id} needs human review — ${payload.reason ?? "audit failed 2x"}`;
+      return `🚨 ${id} needs your help — couldn't fix it after ${attempt} ${attempt === 1 ? "try" : "tries"}`;
     case "stuck":
-      return `⏰ ${id} stuck — ${payload.reason ?? "stale 2h"}`;
+      return `⏰ ${id} stuck — ${payload.reason ?? "inactive for 2h"}`;
     case "watchdog_kill":
-      return `⚡ ${id} killed by watchdog (${payload.reason ?? "no I/O for 120s"}). ${
-        payload.attempt != null ? `Retrying (attempt ${payload.attempt}).` : "Will retry."
+      return `⚡ ${id} timed out (${payload.reason ?? "no activity for 120s"}). ${
+        payload.attempt != null ? `Retrying (attempt ${attempt}).` : "Will retry."
       }`;
     case "project_progress":
       return `📊 ${payload.title} (${id}): ${payload.status}`;
@@ -134,10 +136,10 @@ export function formatRichMessage(kind: NotifyKind, payload: NotifyPayload): Ric
 
   // Discord embed
   const fields: DiscordEmbed["fields"] = [];
-  if (payload.attempt != null) fields.push({ name: "Attempt", value: String(payload.attempt), inline: true });
+  if (payload.attempt != null) fields.push({ name: "Attempt", value: String((payload.attempt ?? 0) + 1), inline: true });
   if (payload.status) fields.push({ name: "Status", value: payload.status, inline: true });
   if (payload.verdict?.gaps?.length) {
-    fields.push({ name: "Gaps", value: payload.verdict.gaps.join("\n").slice(0, 1024) });
+    fields.push({ name: "Issues to fix", value: payload.verdict.gaps.join("\n").slice(0, 1024) });
   }
   if (payload.reason) fields.push({ name: "Reason", value: payload.reason });
 
@@ -154,10 +156,10 @@ export function formatRichMessage(kind: NotifyKind, payload: NotifyPayload): Ric
     `<b>${escapeHtml(payload.identifier)}</b> — ${escapeHtml(kind.replace(/_/g, " "))}`,
     `<i>${escapeHtml(payload.title)}</i>`,
   ];
-  if (payload.attempt != null) htmlParts.push(`Attempt: <code>${payload.attempt}</code>`);
+  if (payload.attempt != null) htmlParts.push(`Attempt: <code>${(payload.attempt ?? 0) + 1}</code>`);
   if (payload.status) htmlParts.push(`Status: <code>${escapeHtml(payload.status)}</code>`);
   if (payload.verdict?.gaps?.length) {
-    htmlParts.push(`Gaps:\n${payload.verdict.gaps.map(g => `• ${escapeHtml(g)}`).join("\n")}`);
+    htmlParts.push(`Issues to fix:\n${payload.verdict.gaps.map(g => `• ${escapeHtml(g)}`).join("\n")}`);
   }
   if (payload.reason) htmlParts.push(`Reason: ${escapeHtml(payload.reason)}`);
 
@@ -241,6 +243,7 @@ export function parseNotificationsConfig(
 export function createNotifierFromConfig(
   pluginConfig: Record<string, unknown> | undefined,
   runtime: PluginRuntime,
+  api?: OpenClawPluginApi,
 ): NotifyFn {
   const config = parseNotificationsConfig(pluginConfig);
 
@@ -260,6 +263,14 @@ export function createNotifierFromConfig(
           await sendToTarget(target, message, runtime);
         } catch (err) {
           console.error(`Notify error (${target.channel}:${target.target}):`, err);
+          if (api) {
+            emitDiagnostic(api, {
+              event: "notify_failed",
+              identifier: payload.identifier,
+              phase: kind,
+              error: String(err),
+            });
+          }
         }
       }),
     );

package/src/infra/observability.test.ts

@@ -0,0 +1,85 @@
+import { describe, it, expect, vi } from "vitest";
+import { emitDiagnostic, type DiagnosticPayload } from "./observability.ts";
+
+function makeApi(infoFn = vi.fn()) {
+  return { logger: { info: infoFn } } as any;
+}
+
+describe("emitDiagnostic", () => {
+  it("emits JSON with [linear:diagnostic] prefix via api.logger.info", () => {
+    const info = vi.fn();
+    const api = makeApi(info);
+    emitDiagnostic(api, { event: "webhook_received", identifier: "ISS-42" });
+    expect(info).toHaveBeenCalledOnce();
+    const line = info.mock.calls[0][0] as string;
+    expect(line).toMatch(/^\[linear:diagnostic\] \{/);
+    const json = JSON.parse(line.replace("[linear:diagnostic] ", ""));
+    expect(json.event).toBe("webhook_received");
+    expect(json.identifier).toBe("ISS-42");
+  });
+
+  it("includes all payload fields in JSON output", () => {
+    const info = vi.fn();
+    const api = makeApi(info);
+    const payload: DiagnosticPayload = {
+      event: "dispatch_started",
+      identifier: "ISS-99",
+      issueId: "abc-123",
+      phase: "planning",
+      from: "triage",
+      to: "execution",
+      attempt: 2,
+      tier: "gold",
+      webhookType: "Comment",
+      webhookAction: "create",
+      channel: "discord",
+      target: "kaylee",
+      error: "none",
+      durationMs: 1234,
+    };
+    emitDiagnostic(api, payload);
+    const json = JSON.parse((info.mock.calls[0][0] as string).replace("[linear:diagnostic] ", ""));
+    expect(json).toMatchObject(payload);
+  });
+
+  it("works with partial payload (only event + identifier)", () => {
+    const info = vi.fn();
+    const api = makeApi(info);
+    emitDiagnostic(api, { event: "health_check" });
+    const json = JSON.parse((info.mock.calls[0][0] as string).replace("[linear:diagnostic] ", ""));
+    expect(json.event).toBe("health_check");
+    expect(json.identifier).toBeUndefined();
+  });
+
+  it("never throws even if logger throws", () => {
+    const api = makeApi(() => { throw new Error("logger exploded"); });
+    expect(() => {
+      emitDiagnostic(api, { event: "notify_failed", identifier: "ISS-1" });
+    }).not.toThrow();
+  });
+
+  it("includes timestamp-relevant fields — payload is faithfully serialized", () => {
+    const info = vi.fn();
+    const api = makeApi(info);
+    const now = Date.now();
+    emitDiagnostic(api, { event: "phase_transition", identifier: "ISS-7", timestamp: now } as any);
+    const json = JSON.parse((info.mock.calls[0][0] as string).replace("[linear:diagnostic] ", ""));
+    expect(json.timestamp).toBe(now);
+  });
+
+  it("handles payload with special characters", () => {
+    const info = vi.fn();
+    const api = makeApi(info);
+    emitDiagnostic(api, {
+      event: "notify_sent",
+      identifier: 'ISS-"special"',
+      error: "line1\nline2\ttab",
+      channel: "<script>alert('xss')</script>",
+    });
+    expect(info).toHaveBeenCalledOnce();
+    const json = JSON.parse((info.mock.calls[0][0] as string).replace("[linear:diagnostic] ", ""));
+    expect(json.identifier).toBe('ISS-"special"');
+    expect(json.error).toBe("line1\nline2\ttab");
+    expect(json.channel).toBe("<script>alert('xss')</script>");
+  });
+});

package/src/pipeline/artifacts.test.ts

@@ -337,11 +337,13 @@ describe("buildSummaryFromArtifacts", () => {
 // ---------------------------------------------------------------------------
 
 describe("writeDispatchMemory", () => {
-  it("creates memory/ dir and writes file", () => {
+  it("creates memory/ dir and writes file with frontmatter", () => {
     const tmp = makeTmpDir();
     writeDispatchMemory("API-100", "summary content", tmp);
     const content = readFileSync(join(tmp, "memory", "dispatch-API-100.md"), "utf-8");
-    expect(content).toBe("summary content");
+    expect(content).toContain("---\n");
+    expect(content).toContain('issue: "API-100"');
+    expect(content).toContain("summary content");
   });
 
   it("overwrites on second call", () => {
@@ -349,7 +351,28 @@ describe("writeDispatchMemory", () => {
     writeDispatchMemory("API-100", "first", tmp);
     writeDispatchMemory("API-100", "second", tmp);
     const content = readFileSync(join(tmp, "memory", "dispatch-API-100.md"), "utf-8");
-    expect(content).toBe("second");
+    expect(content).toContain("second");
+    expect(content).not.toContain("first");
+  });
+
+  it("includes custom metadata in frontmatter", () => {
+    const tmp = makeTmpDir();
+    writeDispatchMemory("CT-50", "done summary", tmp, {
+      title: "Fix login bug",
+      tier: "senior",
+      status: "done",
+      project: "Auth",
+      attempts: 2,
+      model: "kimi-k2.5",
+    });
+    const content = readFileSync(join(tmp, "memory", "dispatch-CT-50.md"), "utf-8");
+    expect(content).toContain('title: "Fix login bug"');
+    expect(content).toContain('tier: "senior"');
+    expect(content).toContain('status: "done"');
+    expect(content).toContain('project: "Auth"');
+    expect(content).toContain("attempts: 2");
+    expect(content).toContain('model: "kimi-k2.5"');
+    expect(content).toContain("done summary");
   });
 });
 

package/src/pipeline/dispatch-state.ts

@@ -58,6 +58,7 @@ export interface ActiveDispatch {
   auditSessionKey?: string;     // session key for current audit sub-agent
   stuckReason?: string;         // only set when status === "stuck"
   issueTitle?: string;          // for artifact summaries and memory headings
+  worktrees?: Array<{ repoName: string; path: string; branch: string }>;
 }
 
 export interface CompletedDispatch {