@calltelemetry/openclaw-linear 0.6.1 → 0.7.1

package/src/infra/cli.ts

@@ -5,14 +5,20 @@ import type { Command } from "commander";
 import type { OpenClawPluginApi } from "openclaw/plugin-sdk";
 import { createInterface } from "node:readline";
 import { exec } from "node:child_process";
-import { readFileSync, writeFileSync } from "node:fs";
-import { readFileSync as readFileSyncFs, existsSync } from "node:fs";
+import { readFileSync, writeFileSync, existsSync } from "node:fs";
 import { join, dirname } from "node:path";
 import { fileURLToPath } from "node:url";
 import { resolveLinearToken, AUTH_PROFILES_PATH, LINEAR_GRAPHQL_URL } from "../api/linear-api.js";
 import { LINEAR_OAUTH_AUTH_URL, LINEAR_OAUTH_TOKEN_URL, LINEAR_AGENT_SCOPES } from "../api/auth.js";
 import { listWorktrees } from "./codex-worktree.js";
 import { loadPrompts, clearPromptCache } from "../pipeline/pipeline.js";
+import {
+  formatMessage,
+  parseNotificationsConfig,
+  sendToTarget,
+  type NotifyKind,
+  type NotifyPayload,
+} from "./notify.js";
 
 function prompt(question: string): Promise<string> {
   const rl = createInterface({ input: process.stdin, output: process.stdout });
@@ -251,33 +257,21 @@ export function registerCli(program: Command, api: OpenClawPluginApi): void {
 
   prompts
     .command("show")
-    .description("Print current prompts.yaml content")
-    .action(async () => {
+    .description("Print resolved prompts (global or per-project)")
+    .option("--worktree <path>", "Show merged prompts for a specific worktree")
+    .action(async (opts: { worktree?: string }) => {
       const pluginConfig = (api as any).pluginConfig as Record<string, unknown> | undefined;
-      const customPath = pluginConfig?.promptsPath as string | undefined;
+      clearPromptCache();
+      const loaded = loadPrompts(pluginConfig, opts.worktree);
 
-      let resolvedPath: string;
-      if (customPath) {
-        resolvedPath = customPath.startsWith("~")
-          ? customPath.replace("~", process.env.HOME ?? "")
-          : customPath;
+      if (opts.worktree) {
+        console.log(`\nResolved prompts for worktree: ${opts.worktree}\n`);
       } else {
-        const pluginRoot = join(dirname(fileURLToPath(import.meta.url)), "../..");
-        resolvedPath = join(pluginRoot, "prompts.yaml");
+        console.log(`\nGlobal resolved prompts\n`);
       }
 
-      console.log(`\nPrompts file: ${resolvedPath}\n`);
-
-      try {
-        const content = readFileSyncFs(resolvedPath, "utf-8");
-        console.log(content);
-      } catch {
-        console.log("(file not found — using built-in defaults)\n");
-        // Show the loaded defaults
-        clearPromptCache();
-        const loaded = loadPrompts(pluginConfig);
-        console.log(JSON.stringify(loaded, null, 2));
-      }
+      console.log(JSON.stringify(loaded, null, 2));
+      console.log();
     });
 
   prompts
@@ -303,13 +297,14 @@ export function registerCli(program: Command, api: OpenClawPluginApi): void {
 
   prompts
     .command("validate")
-    .description("Validate prompts.yaml structure")
-    .action(async () => {
+    .description("Validate prompts.yaml structure (global or per-project)")
+    .option("--worktree <path>", "Validate merged prompts for a specific worktree")
+    .action(async (opts: { worktree?: string }) => {
       const pluginConfig = (api as any).pluginConfig as Record<string, unknown> | undefined;
       clearPromptCache();
 
       try {
-        const loaded = loadPrompts(pluginConfig);
+        const loaded = loadPrompts(pluginConfig, opts.worktree);
         const errors: string[] = [];
 
         if (!loaded.worker?.system) errors.push("Missing worker.system");
@@ -329,13 +324,14 @@ export function registerCli(program: Command, api: OpenClawPluginApi): void {
           }
         }
 
+        const label = opts.worktree ? `worktree ${opts.worktree}` : "global";
         if (errors.length > 0) {
-          console.log("\nValidation FAILED:\n");
+          console.log(`\nValidation FAILED (${label}):\n`);
           for (const e of errors) console.log(`  - ${e}`);
           console.log();
           process.exitCode = 1;
         } else {
-          console.log("\nValidation PASSED — all sections and template variables present.\n");
+          console.log(`\nValidation PASSED (${label}) — all sections and template variables present.\n`);
         }
       } catch (err) {
         console.error(`\nFailed to load prompts: ${err}\n`);
@@ -343,6 +339,265 @@ export function registerCli(program: Command, api: OpenClawPluginApi): void {
       }
     });
 
+  prompts
+    .command("init")
+    .description("Scaffold per-project .claw/prompts.yaml in a worktree")
+    .argument("<worktree-path>", "Path to the worktree")
+    .action(async (worktreePath: string) => {
+      const { mkdirSync, writeFileSync: writeFS } = await import("node:fs");
+      const clawDir = join(worktreePath, ".claw");
+      const promptsFile = join(clawDir, "prompts.yaml");
+
+      if (existsSync(promptsFile)) {
+        console.log(`\n  ${promptsFile} already exists.\n`);
+        return;
+      }
+
+      mkdirSync(clawDir, { recursive: true });
+      writeFS(promptsFile, [
+        "# Per-project prompt overrides for Linear Agent pipeline.",
+        "# Only include sections/fields you want to override.",
+        "# Unspecified fields inherit from the global prompts.yaml.",
+        "#",
+        "# Available sections: worker, audit, rework",
+        "# Template variables: {{identifier}}, {{title}}, {{description}}, {{worktreePath}}, {{tier}}, {{attempt}}, {{gaps}}",
+        "",
+        "# worker:",
+        "#   system: \"Custom system prompt for workers in this project.\"",
+        "#   task: \"Implement issue {{identifier}}: {{title}}\\n\\n{{description}}\\n\\nWorktree: {{worktreePath}}\"",
+        "",
+        "# audit:",
+        "#   system: \"Custom audit system prompt for this project.\"",
+        "",
+        "# rework:",
+        "#   addendum: \"Custom rework addendum for this project.\"",
+        "",
+      ].join("\n"), "utf-8");
+
+      console.log(`\n  Created: ${promptsFile}`);
+      console.log(`  Edit this file to customize prompts for this worktree.\n`);
+    });
+
+  prompts
+    .command("diff")
+    .description("Show differences between global and per-project prompts")
+    .argument("<worktree-path>", "Path to the worktree")
+    .action(async (worktreePath: string) => {
+      const pluginConfig = (api as any).pluginConfig as Record<string, unknown> | undefined;
+      clearPromptCache();
+
+      const global = loadPrompts(pluginConfig);
+      const merged = loadPrompts(pluginConfig, worktreePath);
+
+      const projectFile = join(worktreePath, ".claw", "prompts.yaml");
+      if (!existsSync(projectFile)) {
+        console.log(`\n  No per-project prompts at ${projectFile}`);
+        console.log(`  Run 'openclaw openclaw-linear prompts init ${worktreePath}' to create one.\n`);
+        return;
+      }
+
+      console.log(`\nPrompt diff: global vs ${worktreePath}\n`);
+
+      let hasDiffs = false;
+      for (const section of ["worker", "audit", "rework"] as const) {
+        const globalSection = global[section] as Record<string, string>;
+        const mergedSection = merged[section] as Record<string, string>;
+        for (const [key, val] of Object.entries(mergedSection)) {
+          if (globalSection[key] !== val) {
+            hasDiffs = true;
+            console.log(`  ${section}.${key}:`);
+            console.log(`    global:  ${globalSection[key]?.slice(0, 100)}...`);
+            console.log(`    project: ${val.slice(0, 100)}...`);
+            console.log();
+          }
+        }
+      }
+
+      if (!hasDiffs) {
+        console.log("  No differences — per-project prompts match global.\n");
+      }
+    });
+
+  // --- openclaw openclaw-linear notify ---
+  const notifyCmd = linear
+    .command("notify")
+    .description("Manage dispatch lifecycle notifications");
+
+  notifyCmd
+    .command("status")
+    .description("Show current notification target configuration")
+    .action(async () => {
+      const pluginConfig = (api as any).pluginConfig as Record<string, unknown> | undefined;
+      const config = parseNotificationsConfig(pluginConfig);
+
+      console.log("\nNotification Targets");
+      console.log("─".repeat(50));
+
+      if (!config.targets?.length) {
+        console.log("\n  No notification targets configured.");
+        console.log("  Run 'openclaw openclaw-linear notify setup' to configure.\n");
+        return;
+      }
+
+      for (const t of config.targets) {
+        const acct = t.accountId ? ` (account: ${t.accountId})` : "";
+        console.log(`  ${t.channel}:  ${t.target}${acct}`);
+      }
+
+      // Show event toggles if any are suppressed
+      const suppressed = Object.entries(config.events ?? {})
+        .filter(([, v]) => v === false)
+        .map(([k]) => k);
+      if (suppressed.length > 0) {
+        console.log(`\n  Suppressed events: ${suppressed.join(", ")}`);
+      }
+
+      console.log();
+    });
+
+  notifyCmd
+    .command("test")
+    .description("Send a test notification to all configured targets")
+    .option("--channel <name>", "Test only targets for a specific channel (discord, slack, telegram, etc.)")
+    .action(async (opts: { channel?: string }) => {
+      const pluginConfig = (api as any).pluginConfig as Record<string, unknown> | undefined;
+      const config = parseNotificationsConfig(pluginConfig);
+
+      const testPayload: NotifyPayload = {
+        identifier: "TEST-0",
+        title: "Test notification from Linear plugin",
+        status: "test",
+      };
+      const testKind: NotifyKind = "dispatch";
+      const message = formatMessage(testKind, testPayload);
+
+      console.log("\nSending test notification...\n");
+
+      if (!config.targets?.length) {
+        console.error("  No notification targets configured. Run 'openclaw openclaw-linear notify setup' first.\n");
+        process.exitCode = 1;
+        return;
+      }
+
+      const targets = opts.channel
+        ? config.targets.filter((t) => t.channel === opts.channel)
+        : config.targets;
+
+      if (targets.length === 0) {
+        console.error(`  No targets found for channel "${opts.channel}".\n`);
+        process.exitCode = 1;
+        return;
+      }
+
+      for (const target of targets) {
+        try {
+          await sendToTarget(target, message, api.runtime);
+          console.log(`  ${target.channel}:  SENT to ${target.target}`);
+          console.log(`            "${message}"`);
+        } catch (err) {
+          console.error(`  ${target.channel}:  FAILED — ${err instanceof Error ? err.message : String(err)}`);
+        }
+      }
+
+      console.log();
+    });
+
+  notifyCmd
+    .command("setup")
+    .description("Interactive setup for notification targets")
+    .action(async () => {
+      const pluginConfig = (api as any).pluginConfig as Record<string, unknown> | undefined;
+      const config = parseNotificationsConfig(pluginConfig);
+
+      console.log("\nNotification Target Setup");
+      console.log("─".repeat(50));
+      console.log("  Dispatch lifecycle notifications can be sent to any OpenClaw channel.");
+      console.log("  Add multiple targets for fan-out delivery.\n");
+
+      // Show current targets
+      if (config.targets?.length) {
+        console.log("  Current targets:");
+        for (const t of config.targets) {
+          const acct = t.accountId ? ` (account: ${t.accountId})` : "";
+          console.log(`    ${t.channel}: ${t.target}${acct}`);
+        }
+        console.log();
+      }
+
+      const newTargets = [...(config.targets ?? [])];
+      const supportedChannels = ["discord", "slack", "telegram", "signal"];
+
+      // Add targets loop
+      let addMore = true;
+      while (addMore) {
+        const channelAnswer = await prompt(
+          `Add notification target? (${supportedChannels.join("/")}) or blank to finish: `,
+        );
+        if (!channelAnswer) {
+          addMore = false;
+          break;
+        }
+
+        const channel = channelAnswer.toLowerCase().trim();
+        const targetId = await prompt(`  ${channel} target ID (channel/group/user): `);
+        if (!targetId) continue;
+
+        let accountId: string | undefined;
+        if (channel === "slack") {
+          const acct = await prompt("  Slack account ID (leave blank for default): ");
+          accountId = acct || undefined;
+        }
+
+        newTargets.push({ channel, target: targetId, ...(accountId ? { accountId } : {}) });
+        console.log(`  Added: ${channel} → ${targetId}\n`);
+      }
+
+      // Summary
+      console.log("\nConfiguration Summary");
+      console.log("─".repeat(50));
+      if (newTargets.length === 0) {
+        console.log("  No targets configured (notifications disabled).");
+      } else {
+        for (const t of newTargets) {
+          const acct = t.accountId ? ` (account: ${t.accountId})` : "";
+          console.log(`  ${t.channel}: ${t.target}${acct}`);
+        }
+      }
+
+      if (JSON.stringify(newTargets) === JSON.stringify(config.targets ?? [])) {
+        console.log("\n  No changes made.\n");
+        return;
+      }
+
+      // Write config
+      const confirmAnswer = await prompt("\nApply these changes? [Y/n]: ");
+      if (confirmAnswer.toLowerCase() === "n") {
+        console.log("  Aborted.\n");
+        return;
+      }
+
+      try {
+        const runtimeConfig = api.runtime.config.loadConfig() as Record<string, any>;
+        const pluginEntries = runtimeConfig.plugins?.entries ?? {};
+        const linearConfig = pluginEntries["openclaw-linear"]?.config ?? {};
+        linearConfig.notifications = {
+          ...linearConfig.notifications,
+          targets: newTargets,
+        };
+        pluginEntries["openclaw-linear"] = {
+          ...pluginEntries["openclaw-linear"],
+          config: linearConfig,
+        };
+        runtimeConfig.plugins = { ...runtimeConfig.plugins, entries: pluginEntries };
+        api.runtime.config.writeConfigFile(runtimeConfig);
+        console.log("\n  Configuration saved. Restart gateway to apply: systemctl --user restart openclaw-gateway\n");
+      } catch (err) {
+        console.error(`\n  Failed to save config: ${err instanceof Error ? err.message : String(err)}`);
+        console.error("  You can manually add these values to openclaw.json → plugins.entries.openclaw-linear.config\n");
+        process.exitCode = 1;
+      }
+    });
+
   // --- openclaw openclaw-linear doctor ---
   linear
     .command("doctor")

package/src/infra/codex-worktree.ts

@@ -3,6 +3,7 @@ import { existsSync, statSync, readdirSync, mkdirSync } from "node:fs";
 import { homedir } from "node:os";
 import path from "node:path";
 import { ensureGitignore } from "../pipeline/artifacts.js";
+import type { RepoConfig } from "./multi-repo.js";
 
 const DEFAULT_BASE_REPO = "/home/claw/ai-workspace";
 const DEFAULT_WORKTREE_BASE_DIR = path.join(homedir(), ".openclaw", "worktrees");
@@ -117,6 +118,88 @@ export function createWorktree(
   return { path: worktreePath, branch, resumed: false };
 }
 
+export interface MultiWorktreeResult {
+  /** Parent directory containing all repo worktrees for this issue. */
+  parentPath: string;
+  worktrees: Array<{
+    repoName: string;
+    path: string;
+    branch: string;
+    resumed: boolean;
+  }>;
+}
+
+/**
+ * Create worktrees for multiple repos.
+ *
+ * Layout: {baseDir}/{issueIdentifier}/{repoName}/
+ * Branch: codex/{issueIdentifier} (same branch name in each repo)
+ *
+ * Each individual repo worktree follows the same idempotent/resume logic
+ * as createWorktree: if the worktree or branch already exists, it resumes.
+ */
+export function createMultiWorktree(
+  identifier: string,
+  repos: RepoConfig[],
+  opts?: { baseDir?: string },
+): MultiWorktreeResult {
+  const baseDir = resolveBaseDir(opts?.baseDir);
+  const parentPath = path.join(baseDir, identifier);
+
+  // Ensure parent directory exists
+  if (!existsSync(parentPath)) {
+    mkdirSync(parentPath, { recursive: true });
+  }
+
+  const branch = `codex/${identifier}`;
+  const worktrees: MultiWorktreeResult["worktrees"] = [];
+
+  for (const repo of repos) {
+    if (!existsSync(repo.path)) {
+      throw new Error(`Repo not found: ${repo.name} at ${repo.path}`);
+    }
+
+    const worktreePath = path.join(parentPath, repo.name);
+
+    // Fetch latest from origin (best effort)
+    try {
+      git(["fetch", "origin"], repo.path);
+    } catch {
+      // Offline or no remote — continue with local state
+    }
+
+    // Idempotent: if worktree already exists, resume it
+    if (existsSync(worktreePath)) {
+      try {
+        git(["rev-parse", "--git-dir"], worktreePath);
+        ensureGitignore(worktreePath);
+        worktrees.push({ repoName: repo.name, path: worktreePath, branch, resumed: true });
+        continue;
+      } catch {
+        // Directory exists but isn't a valid worktree — remove and recreate
+        try {
+          git(["worktree", "remove", "--force", worktreePath], repo.path);
+        } catch { /* best effort */ }
+      }
+    }
+
+    // Check if branch already exists (resume scenario)
+    const exists = branchExistsInRepo(branch, repo.path);
+
+    if (exists) {
+      git(["worktree", "add", worktreePath, branch], repo.path);
+      ensureGitignore(worktreePath);
+      worktrees.push({ repoName: repo.name, path: worktreePath, branch, resumed: true });
+    } else {
+      git(["worktree", "add", "-b", branch, worktreePath], repo.path);
+      ensureGitignore(worktreePath);
+      worktrees.push({ repoName: repo.name, path: worktreePath, branch, resumed: false });
+    }
+  }
+
+  return { parentPath, worktrees };
+}
+
 /**
  * Check if a branch exists in the repo.
  */

package/src/infra/commands.ts

@@ -0,0 +1,156 @@
+/**
+ * commands.ts — Zero-LLM slash commands for dispatch operations.
+ *
+ * Registered via api.registerCommand(). These commands bypass the AI agent
+ * entirely — they read/write dispatch state directly and return formatted text.
+ */
+import type { OpenClawPluginApi } from "openclaw/plugin-sdk";
+import {
+  readDispatchState,
+  getActiveDispatch,
+  listActiveDispatches,
+  removeActiveDispatch,
+  transitionDispatch,
+  TransitionError,
+  registerDispatch,
+  type ActiveDispatch,
+} from "../pipeline/dispatch-state.js";
+
+export function registerDispatchCommands(api: OpenClawPluginApi): void {
+  const pluginConfig = (api as any).pluginConfig as Record<string, unknown> | undefined;
+  const statePath = pluginConfig?.dispatchStatePath as string | undefined;
+
+  api.registerCommand({
+    name: "dispatch",
+    description: "Manage dispatches: list, status <id>, retry <id>, escalate <id>",
+    acceptsArgs: true,
+    handler: async (ctx) => {
+      const args = (ctx.args ?? "").trim().split(/\s+/);
+      const sub = args[0]?.toLowerCase();
+      const id = args[1];
+
+      if (!sub || sub === "list") {
+        return await handleList(statePath);
+      }
+      if (sub === "status" && id) {
+        return await handleStatus(id, statePath);
+      }
+      if (sub === "retry" && id) {
+        return await handleRetry(id, statePath, api);
+      }
+      if (sub === "escalate" && id) {
+        const reason = args.slice(2).join(" ") || "manual escalation";
+        return await handleEscalate(id, reason, statePath, api);
+      }
+
+      return {
+        text: [
+          "**Dispatch Commands:**",
+          "`/dispatch list` — show active dispatches",
+          "`/dispatch status <id>` — phase/attempt details",
+          "`/dispatch retry <id>` — reset stuck → dispatched",
+          "`/dispatch escalate <id> [reason]` — force to stuck",
+        ].join("\n"),
+      };
+    },
+  });
+}
+
+async function handleList(statePath?: string) {
+  const state = await readDispatchState(statePath);
+  const active = listActiveDispatches(state);
+
+  if (active.length === 0) {
+    return { text: "No active dispatches." };
+  }
+
+  const lines = active.map((d) => {
+    const age = Math.round((Date.now() - new Date(d.dispatchedAt).getTime()) / 60_000);
+    return `**${d.issueIdentifier}** — ${d.status} (${d.tier}, attempt ${d.attempt}, ${age}m)`;
+  });
+
+  return { text: `**Active Dispatches (${active.length})**\n${lines.join("\n")}` };
+}
+
+async function handleStatus(id: string, statePath?: string) {
+  const state = await readDispatchState(statePath);
+  const d = getActiveDispatch(state, id);
+
+  if (!d) {
+    const completed = state.dispatches.completed[id];
+    if (completed) {
+      return {
+        text: `**${id}** — completed (${completed.status}, ${completed.tier}, ${completed.totalAttempts ?? 0} attempts)`,
+      };
+    }
+    return { text: `No dispatch found for ${id}.` };
+  }
+
+  const age = Math.round((Date.now() - new Date(d.dispatchedAt).getTime()) / 60_000);
+  const lines = [
+    `**${d.issueIdentifier}** — ${d.issueTitle ?? d.issueIdentifier}`,
+    `Status: ${d.status} | Tier: ${d.tier} | Attempt: ${d.attempt}`,
+    `Age: ${age}m | Worktree: \`${d.worktreePath}\``,
+    d.stuckReason ? `Stuck reason: ${d.stuckReason}` : "",
+    d.agentSessionId ? `Session: ${d.agentSessionId}` : "",
+  ].filter(Boolean);
+
+  return { text: lines.join("\n") };
+}
+
+async function handleRetry(id: string, statePath: string | undefined, api: OpenClawPluginApi) {
+  const state = await readDispatchState(statePath);
+  const d = getActiveDispatch(state, id);
+
+  if (!d) {
+    return { text: `No active dispatch found for ${id}.` };
+  }
+
+  if (d.status !== "stuck") {
+    return { text: `Cannot retry ${id} — status is ${d.status} (must be stuck).` };
+  }
+
+  // Remove and re-register with reset status
+  await removeActiveDispatch(id, statePath);
+  const retryDispatch: ActiveDispatch = {
+    ...d,
+    status: "dispatched",
+    stuckReason: undefined,
+    workerSessionKey: undefined,
+    auditSessionKey: undefined,
+    dispatchedAt: new Date().toISOString(),
+  };
+  await registerDispatch(id, retryDispatch, statePath);
+
+  api.logger.info(`/dispatch retry: ${id} reset from stuck → dispatched`);
+  return { text: `**${id}** reset to dispatched. Will be picked up by next dispatch cycle.` };
+}
+
+async function handleEscalate(
+  id: string,
+  reason: string,
+  statePath: string | undefined,
+  api: OpenClawPluginApi,
+) {
+  const state = await readDispatchState(statePath);
+  const d = getActiveDispatch(state, id);
+
+  if (!d) {
+    return { text: `No active dispatch found for ${id}.` };
+  }
+
+  if (d.status === "stuck" || d.status === "done" || d.status === "failed") {
+    return { text: `Cannot escalate ${id} — already in terminal state: ${d.status}.` };
+  }
+
+  try {
+    await transitionDispatch(id, d.status, "stuck", { stuckReason: reason }, statePath);
+    api.logger.info(`/dispatch escalate: ${id} → stuck (${reason})`);
+    return { text: `**${id}** escalated to stuck: ${reason}` };
+  } catch (err) {
+    if (err instanceof TransitionError) {
+      return { text: `CAS conflict: ${err.message}` };
+    }
+    return { text: `Error: ${String(err)}` };
+  }
+}

package/src/infra/doctor.test.ts

@@ -258,12 +258,12 @@ describe("checkConnectivity", () => {
     expect(apiCheck?.severity).toBe("pass");
   });
 
-  it("reports Discord not configured as pass", async () => {
+  it("reports notifications not configured as pass", async () => {
     vi.stubGlobal("fetch", vi.fn(async () => { throw new Error("should not be called"); }));
     const checks = await checkConnectivity({});
-    const discordCheck = checks.find((c) => c.label.includes("Discord"));
-    expect(discordCheck?.severity).toBe("pass");
-    expect(discordCheck?.label).toContain("not configured");
+    const notifCheck = checks.find((c) => c.label.includes("Notifications"));
+    expect(notifCheck?.severity).toBe("pass");
+    expect(notifCheck?.label).toContain("not configured");
   });
 
   it("reports webhook skip when gateway not running", async () => {

package/src/infra/doctor.ts

@@ -530,36 +530,14 @@ export async function checkConnectivity(pluginConfig?: Record<string, unknown>,
     }
   }
 
-  // Discord notifications
-  const flowDiscordChannel = pluginConfig?.flowDiscordChannel as string | undefined;
-  if (!flowDiscordChannel) {
-    checks.push(pass("Discord notifications: not configured (skipped)"));
+  // Notification targets
+  const notifRaw = pluginConfig?.notifications as { targets?: { channel: string; target: string }[] } | undefined;
+  const notifTargets = notifRaw?.targets ?? [];
+  if (notifTargets.length === 0) {
+    checks.push(pass("Notifications: not configured (skipped)"));
   } else {
-    // Read Discord bot token from openclaw.json
-    let discordBotToken: string | undefined;
-    try {
-      const configPath = join(homedir(), ".openclaw", "openclaw.json");
-      const config = JSON.parse(readFileSync(configPath, "utf8"));
-      discordBotToken = config?.channels?.discord?.token as string | undefined;
-    } catch {
-      // Can't read config
-    }
-
-    if (!discordBotToken) {
-      checks.push(warn("Discord notifications: no bot token found in openclaw.json"));
-    } else {
-      try {
-        const res = await fetch(`https://discord.com/api/v10/channels/${flowDiscordChannel}`, {
-          headers: { Authorization: `Bot ${discordBotToken}` },
-        });
-        if (res.ok) {
-          checks.push(pass("Discord notifications: enabled"));
-        } else {
-          checks.push(warn(`Discord channel check: ${res.status} ${res.statusText}`));
-        }
-      } catch (err) {
-        checks.push(warn(`Discord API unreachable: ${err instanceof Error ? err.message : String(err)}`));
-      }
+    for (const t of notifTargets) {
+      checks.push(pass(`Notifications: ${t.channel} → ${t.target}`));
     }
   }