mulmoclaude 0.5.2 → 0.6.0

package/server/api/routes/wiki.ts

@@ -2,7 +2,7 @@ import { Router, Request, Response } from "express";
 import path from "path";
 import { WORKSPACE_PATHS } from "../../workspace/paths.js";
 import { readTextSafeSync, readTextSafe } from "../../utils/files/safe.js";
-import { writeFileAtomic } from "../../utils/files/atomic.js";
+import { writeWikiPage } from "../../workspace/wiki-pages/io.js";
 import { getPageIndex } from "./wiki/pageIndex.js";
 import { parseFrontmatterTags } from "./wiki/frontmatter.js";
 import { badRequest, notFound } from "../../utils/httpError.js";
@@ -15,6 +15,7 @@ import { previewSnippet } from "../../utils/logPreview.js";
 // different name avoids the no-shadow clash without renaming the
 // long-standing local.
 import { errorMessage as formatError } from "../../utils/errors.js";
+import { BULLET_LINK_PATTERN, BULLET_WIKI_LINK_PATTERN } from "../../utils/regex.js";
 
 const router = Router();
 
@@ -44,12 +45,12 @@ export function wikiSlugify(text: string): string {
 }
 
 const TABLE_SEPARATOR_PATTERN = /^\|[\s|:-]+\|$/;
-// Capture the href (group 2) alongside the title (group 1) so we can
-// derive the slug from the file name instead of re-slugifying the
-// title. This matters for non-ASCII titles like "さくらインターネット"
+// Bullet-link patterns (BULLET_LINK_PATTERN, BULLET_WIKI_LINK_PATTERN)
+// live in `server/utils/regex.ts` alongside other server regex audit
+// notes. Capture the href (group 2) alongside the title (group 1) so
+// we can derive the slug from the file name instead of re-slugifying
+// the title — important for non-ASCII titles like "さくらインターネット"
 // where `wikiSlugify` returns "" and the slug would otherwise be lost.
-const BULLET_LINK_PATTERN = /^[-*]\s+\[([^\]]+)\]\(([^)]*)\)(?:\s*[—–-]\s*(.*))?/;
-const BULLET_WIKI_LINK_PATTERN = /^[-*]\s+\[\[([^\]]+)\]\](?:\s*[—–-]\s*(.*))?/;
 // Unicode-aware tag body: any letter or number in any script
 // (so Japanese / Chinese / Korean tags like `#クラウド` or `#可視化`
 // work), plus `-` and `_` as internal joiners. First char is a
@@ -103,6 +104,28 @@ export function buildTableColumnMap(headerRow: string): Map<string, number> {
   return map;
 }
 
+interface TableColumnIndices {
+  slug: number;
+  title: number;
+  summary: number;
+  /** Undefined when the table has no `tags` column — caller skips
+   *  the tags lookup entirely and the row gets `tags: []`. */
+  tags: number | undefined;
+}
+
+/** Resolve the per-column indices the row parser needs. Falls back
+ *  to positional defaults (0/1/2) when the table has no header map.
+ *  "summary" is the canonical column name; "description" is accepted
+ *  as a legacy alias used by older fixtures. */
+function resolveTableColumnIndices(columnMap: Map<string, number> | null): TableColumnIndices {
+  return {
+    slug: columnMap?.get("slug") ?? 0,
+    title: columnMap?.get("title") ?? 1,
+    summary: columnMap?.get("summary") ?? columnMap?.get("description") ?? 2,
+    tags: columnMap?.get("tags"),
+  };
+}
+
 // Each parser returns the entry it produced (if any). The parent
 // loop tries them in order; the first non-null result wins.
 function parseTableRow(trimmed: string, columnMap: Map<string, number> | null): WikiPageEntry | null {
@@ -111,19 +134,14 @@ function parseTableRow(trimmed: string, columnMap: Map<string, number> | null):
     .slice(1, -1)
     .map((column) => column.trim().replace(/^`|`$/g, ""));
   if (cols.length < 2) return null;
-  const slugIdx = columnMap?.get("slug") ?? 0;
-  const titleIdx = columnMap?.get("title") ?? 1;
-  // Accept either "summary" (the canonical column name in
-  // server/workspace/helps/wiki.md) or "description" (used by the
-  // existing unit test fixture). Fall back to column 2 when the
-  // table has no header map.
-  const summaryIdx = columnMap?.get("summary") ?? columnMap?.get("description") ?? 2;
-  const tagsIdx = columnMap?.get("tags");
-  const slug = cols[slugIdx] ?? "";
-  const title = cols[titleIdx] || slug;
-  const description = cols[summaryIdx] ?? "";
-  const tags = tagsIdx !== undefined ? parseTagsCell(cols[tagsIdx] ?? "") : [];
+
+  const idx = resolveTableColumnIndices(columnMap);
+  const slug = cols[idx.slug] ?? "";
+  const title = cols[idx.title] || slug;
   if (!slug || !title) return null;
+
+  const description = cols[idx.summary] ?? "";
+  const tags = idx.tags !== undefined ? parseTagsCell(cols[idx.tags] ?? "") : [];
   return { title, slug, description, tags };
 }
 
@@ -233,8 +251,9 @@ async function resolvePagePath(pageName: string): Promise<string | null> {
   const indexContent = readFileOrEmpty(indexFile());
   const entries = parseIndexEntries(indexContent);
   const titleMatch = entries.find((entry) => entry.title === pageName);
-  if (titleMatch && slugs.has(titleMatch.slug)) {
-    return path.join(dir, slugs.get(titleMatch.slug)!);
+  if (titleMatch) {
+    const file = slugs.get(titleMatch.slug);
+    if (file) return path.join(dir, file);
   }
 
   return null;
@@ -320,7 +339,7 @@ function buildIndexResponse(action: string): WikiResponse {
 // instructions distinctions that the GET and POST handlers share.
 export function buildPageResponseData(args: { action: string; pageName: string; resolvedTitle: string; content: string; exists: boolean }): WikiResponse {
   const { action, pageName, resolvedTitle, content, exists } = args;
-  const hasContent = !!content;
+  const hasContent = Boolean(content);
   // Three states:
   //   1. !exists              → page file is missing entirely.
   //   2. exists && !hasContent → page file exists but is empty (e.g.,
@@ -370,7 +389,7 @@ export function toPageResponse(args: { action: string; pageName: string; filePat
     pageName,
     resolvedTitle,
     content,
-    exists: !!filePath,
+    exists: Boolean(filePath),
   });
 }
 
@@ -508,9 +527,14 @@ type SaveOutcome = { ok: true; absPath: string } | { ok: false; reason: "not-fou
 async function saveExistingPage(pageName: string, content: string): Promise<SaveOutcome> {
   const absPath = await resolvePagePath(pageName);
   if (!absPath) return { ok: false, reason: "not-found" };
-  // Atomic write: tmp file alongside the destination, fsync, rename.
-  // Prevents a crashed write from leaving the wiki page truncated.
-  await writeFileAtomic(absPath, content);
+  // Funnel through the wiki-page write helper. Atomic write is
+  // guaranteed inside; the helper also routes the (old, new) pair
+  // to the snapshot pipeline (#763 PR 2 — currently a no-op stub).
+  // Editor identity defaults to "user" here because the route is
+  // hit by both LLM (`manageWiki` MCP) and frontend saves; PR 2
+  // disambiguates them via a request-side flag.
+  const slug = path.basename(absPath, ".md");
+  await writeWikiPage(slug, content, { editor: "user" });
   return { ok: true, absPath };
 }
 
@@ -529,7 +553,7 @@ async function handleSaveAction(
     badRequest(res, "pageName required for save action");
     return;
   }
-  const content = req.body.content;
+  const { content } = req.body;
   if (typeof content !== "string") {
     log.warn("wiki", "POST save: missing content", { pageNamePreview: previewSnippet(pageName) });
     badRequest(res, "content (string) required for save action");

package/server/events/file-change.ts

@@ -0,0 +1,83 @@
+// File-change publisher. Single place that knows how to broadcast
+// "this workspace file changed" — every route that writes through the
+// app should call `publishFileChange(relPath)` after a successful
+// write so that subscribed UI tabs (and other browsers) refetch.
+//
+// Module-singleton + `init…` pattern, mirroring `session-store`. The
+// singleton is null at import time so unit-tested route handlers can
+// skip wiring and simply observe a no-op publish.
+//
+// Channel name + payload shape live in `src/config/pubsubChannels.ts`
+// so subscribers can't drift from the publisher.
+
+import { stat } from "node:fs/promises";
+import path from "node:path";
+import type { IPubSub } from "./pub-sub/index.js";
+import { fileChannel, toPosixWorkspacePath, type FileChannelPayload } from "../../src/config/pubsubChannels.js";
+import { workspacePath } from "../workspace/workspace.js";
+import { maybeRegenerateTopicIndex, TOPIC_INDEX_RELATIVE_PATH } from "../workspace/memory/topic-index-hook.js";
+import { log } from "../system/logger/index.js";
+
+let pubsub: IPubSub | null = null;
+
+export function initFileChangePublisher(instance: IPubSub): void {
+  pubsub = instance;
+}
+
+/**
+ * Publish a file-change event for a workspace-relative path. Reads
+ * the post-write `mtimeMs` via `stat` so subscribers get a monotonic
+ * timestamp suitable for both cache-busting (`?v=<mtime>`) and
+ * out-of-order drops. If the stat fails (file just got deleted, race
+ * with another writer, etc.) we fall back to `Date.now()` rather than
+ * dropping the event — losing the notification is worse than an
+ * approximate timestamp.
+ */
+export async function publishFileChange(relativePath: string): Promise<void> {
+  if (!pubsub) return;
+  const absPath = path.join(workspacePath, relativePath);
+  let mtimeMs: number;
+  try {
+    ({ mtimeMs } = await stat(absPath));
+  } catch (err) {
+    log.warn("file-change", "stat failed; falling back to Date.now()", {
+      pathPreview: relativePath,
+      error: err instanceof Error ? err.message : String(err),
+    });
+    mtimeMs = Date.now();
+  }
+  // Normalise once so `payload.path` and the channel suffix can't drift
+  // on Windows / mixed-separator inputs.
+  const posixPath = toPosixWorkspacePath(relativePath);
+  const payload: FileChannelPayload = { path: posixPath, mtimeMs };
+  // Callers fire-and-forget via `void publishFileChange(...)`, so a
+  // throw here would surface as an unhandled rejection (Node terminates
+  // the process by default). Missing one notification is strictly less
+  // bad than killing the server.
+  try {
+    pubsub.publish(fileChannel(posixPath), payload);
+  } catch (err) {
+    log.warn("file-change", "publish failed; subscribers will miss this event", {
+      pathPreview: posixPath,
+      error: err instanceof Error ? err.message : String(err),
+    });
+  }
+  // Side-effect hook: keep the topic-format MEMORY.md index in sync
+  // when a user edits a topic file via the file explorer (#1032).
+  // No-op for non-topic paths. Fire-and-forget so the publish path
+  // stays fast; errors log internally.
+  //
+  // When regen actually runs, also emit a change event for the
+  // index file itself so a FilesView tab pinned to MEMORY.md
+  // refreshes the moment the rebuild lands. The recursive call is
+  // bounded: `MEMORY.md` is excluded by `isTopicFilePath`, so the
+  // second pass returns false without triggering another regen.
+  maybeRegenerateTopicIndex(posixPath)
+    .then((didRegen) => (didRegen ? publishFileChange(TOPIC_INDEX_RELATIVE_PATH) : undefined))
+    .catch(() => {});
+}
+
+/** Test-only — clear the module singleton so each test starts clean. */
+export function _resetFileChangePublisherForTesting(): void {
+  pubsub = null;
+}

package/server/events/notifications.ts

@@ -1,128 +1,285 @@
-// Notification system (#144).
+// Legacy host-side `publishNotification()` entry point — now a thin
+// wrapper over the new notifier engine (PR 4 of feat-encore).
 //
-// Publishes NotificationPayload to:
-//   1. Web pub-sub → bell badge + panel
-//   2. Chat-service bridge → Telegram / CLI
+// The signature is preserved so the existing host call sites
+// (`server/agent/mcp-tools/notify.ts`, `server/api/routes/notifications.ts`,
+// `server/workspace/sources/pipeline/notify.ts`,
+// `server/plugins/diagnostics.ts`) keep working without source changes.
+// Internally it now:
+//   1. Maps the legacy `NotificationKind` source category to a
+//      `pluginPkg` ("todo"/"scheduler"/"agent"/"journal" keep their
+//      names; "push"/"bridge"/"system" collapse under "host").
+//   2. Maps `priority` to engine `severity` ("normal" → "nudge",
+//      "high" → "urgent").
+//   3. Flattens the typed `NotificationAction` to a relative URL
+//      string for `navigateTarget` (forwarded only as metadata —
+//      legacy entries publish with `lifecycle: "fyi"`, so the
+//      `action`-lifecycle rules don't apply and clicking still routes).
+//   4. Stashes the legacy fields (`kind`, `priority`, `action`,
+//      `i18n`, `transportId`, `sessionId`, the caller-supplied dedup
+//      `id`) on `pluginData` so the bell can preserve icon, i18n
+//      localization, and transport routing.
 //
-// Callers (trigger sources) use `publishNotification()` to fire.
-// In-memory store keeps the last N notifications for the bell panel.
-// publishNotification() is wrapped in try-catch so failures never
-// propagate to callers (e.g. endRun in session-store).
+// Bridge push (`chat-service.pushToBridge`) and macOS Reminder push
+// no longer happen inline here — they're owned by adapters that
+// subscribe to the `notifier` pubsub channel. See
+// `server/notifier/legacy-adapters.ts`.
 
-import { PUBSUB_CHANNELS } from "../../src/config/pubsubChannels.js";
+import { PAGE_ROUTES } from "../../src/router/pageRoutes.js";
 import {
-  NOTIFICATION_KINDS,
-  NOTIFICATION_ICONS,
   NOTIFICATION_ACTION_TYPES,
+  NOTIFICATION_KINDS,
   NOTIFICATION_PRIORITIES,
-  type NotificationPayload,
-  type NotificationKind,
+  NOTIFICATION_VIEWS,
   type NotificationAction,
+  type NotificationI18n,
+  type NotificationKind,
   type NotificationPriority,
 } from "../../src/types/notification.js";
+import { publish as notifierPublish } from "../notifier/engine.js";
+import type { NotifierSeverity } from "../notifier/types.js";
 import { ONE_SECOND_MS, MAX_NOTIFICATION_DELAY_SEC } from "../utils/time.js";
 import { log } from "../system/logger/index.js";
 import { makeUuid } from "../utils/id.js";
-import { pushToMacosReminder } from "../system/macosNotify.js";
 
-// ── Dependencies (injected at startup) ──────────────────────────
+// ── Public types ────────────────────────────────────────────────
 
-export interface NotificationDeps {
-  publish: (channel: string, payload: unknown) => void;
-  pushToBridge: (transportId: string, chatId: string, message: string) => void;
+export interface PublishNotificationOpts {
+  kind: NotificationKind;
+  title: string;
+  body?: string;
+  action?: NotificationAction;
+  priority?: NotificationPriority;
+  sessionId?: string;
+  transportId?: string;
+  /** Override the auto-generated UUID with a caller-supplied stable
+   *  id. Used by the plugin-meta diagnostics: the same diagnostic
+   *  id is returned from `/api/plugins/diagnostics`, and `pluginData`
+   *  carries it so `announcePluginMetaDiagnostics` can dedupe across
+   *  reboots without piling identical entries into `active.json`. */
+  id?: string;
+  /** vue-i18n keys + params for clients to localize the title/body.
+   *  Server-side `title` / `body` stay set as English fallbacks for
+   *  logs, macOS Reminder push, and bridge push paths. */
+  i18n?: NotificationI18n;
 }
 
-let deps: NotificationDeps | null = null;
+/** Discriminated marker on `NotifierEntry.pluginData` for entries
+ *  produced by the legacy `publishNotification()` wrapper. The bell
+ *  reads this to preserve the legacy icon, i18n localization, and
+ *  transport routing. New direct callers of `notifier.publish()`
+ *  publish without this shape. */
+export interface LegacyNotifierPluginData {
+  legacy: true;
+  /** Caller-supplied stable id (e.g. plugin-meta diagnostic id), or
+   *  the auto-generated UUID otherwise. Distinct from
+   *  `NotifierEntry.id`, which the engine assigns. */
+  legacyId: string;
+  kind: NotificationKind;
+  priority: NotificationPriority;
+  action: NotificationAction;
+  i18n?: NotificationI18n;
+  transportId?: string;
+  sessionId?: string;
+}
 
-export function initNotifications(injected: NotificationDeps): void {
-  deps = injected;
+export function isLegacyNotifierPluginData(value: unknown): value is LegacyNotifierPluginData {
+  if (value === null || typeof value !== "object") return false;
+  const rec = value as Record<string, unknown>;
+  return rec.legacy === true && typeof rec.legacyId === "string" && typeof rec.kind === "string";
 }
 
-// ── In-memory store ─────────────────────────────────────────────
+// ── Mapping helpers ─────────────────────────────────────────────
 
-const MAX_STORED = 50;
-const store: NotificationPayload[] = [];
+/** Map legacy `NotificationKind` → `pluginPkg`. Source categories
+ *  that come from a domain feature (todo / scheduler / agent /
+ *  journal) keep their names so a future runtime plugin can adopt the
+ *  pluginPkg unchanged; the host-internal categories (push, bridge,
+ *  system) collapse to "host". */
+export function legacyKindToPluginPkg(kind: NotificationKind): string {
+  switch (kind) {
+    case NOTIFICATION_KINDS.todo:
+    case NOTIFICATION_KINDS.scheduler:
+    case NOTIFICATION_KINDS.agent:
+    case NOTIFICATION_KINDS.journal:
+      return kind;
+    case NOTIFICATION_KINDS.push:
+    case NOTIFICATION_KINDS.bridge:
+    case NOTIFICATION_KINDS.system:
+    default:
+      return "host";
+  }
+}
 
-export function getRecentNotifications(): readonly NotificationPayload[] {
-  return store;
+/** Map legacy `priority` → engine `severity`. The legacy badge was
+ *  red unconditionally; mapping `normal` → `nudge` keeps the bell
+ *  visibly amber so users still see "you have notifications," while
+ *  `high` → `urgent` preserves the red escalation for diagnostics
+ *  and similar attention-grabbing items. `info` is reserved for
+ *  future non-bell-coloring callers. */
+export function legacyPriorityToSeverity(priority: NotificationPriority | undefined): NotifierSeverity {
+  return priority === NOTIFICATION_PRIORITIES.high ? "urgent" : "nudge";
 }
 
-// ── Publish ─────────────────────────────────────────────────────
+// ── Per-view URL builders ───────────────────────────────────────
+//
+// Split out from `legacyActionToNavigateTarget` so the dispatcher
+// stays under the cognitive-complexity threshold. Each builder takes
+// the typed target slice it cares about and returns either a relative
+// URL or `undefined` (the latter only when a required field is
+// missing — chat without sessionId).
 
-export interface PublishNotificationOpts {
-  kind: NotificationKind;
-  title: string;
-  body?: string;
-  action?: NotificationAction;
-  priority?: NotificationPriority;
-  sessionId?: string;
-  transportId?: string;
+type NavigateTarget = Extract<NotificationAction, { type: "navigate" }>["target"];
+
+// User/content-derived path segments (slugs, anchors, item ids) ride
+// through `encodeURIComponent` so reserved characters like `?`, `#`,
+// `/`, `%`, `&`, ` ` don't change the URL's structure when interpolated.
+// `PAGE_ROUTES.*` and the literal `pages` segment are static literals
+// — encoding them is unnecessary noise.
+//
+// Dot segments (`.` and `..`) survive `encodeURIComponent` (the dots
+// aren't reserved characters) and would let a slug or path component
+// jump out of its view's namespace once the browser / router applies
+// path normalization. `/files/../chat/sess` collapses to `/chat/sess`,
+// for example. `isSafePathComponent` rejects those segments; consumers
+// either fall back to the view's index (single-component fields like
+// `slug` / `itemId`) or drop the navigate target entirely (chat,
+// where `sessionId` is required, has no usable index).
+
+function isSafePathComponent(segment: string): boolean {
+  return segment !== "." && segment !== "..";
 }
 
-export function publishNotification(opts: PublishNotificationOpts): void {
-  try {
-    const payload: NotificationPayload = {
-      id: makeUuid(),
-      kind: opts.kind,
-      title: opts.title,
-      body: opts.body,
-      icon: NOTIFICATION_ICONS[opts.kind],
-      action: opts.action ?? { type: NOTIFICATION_ACTION_TYPES.none },
-      firedAt: new Date().toISOString(),
-      priority: opts.priority ?? NOTIFICATION_PRIORITIES.normal,
-      sessionId: opts.sessionId,
-      transportId: opts.transportId,
-    };
-
-    // Store for bell panel
-    store.unshift(payload);
-    if (store.length > MAX_STORED) store.length = MAX_STORED;
-
-    // Push to Web UI via pub-sub
-    if (deps) {
-      deps.publish(PUBSUB_CHANNELS.notifications, payload);
-    }
-
-    // Push to bridge (Telegram/CLI)
-    if (deps && opts.transportId) {
-      deps.pushToBridge(opts.transportId, "notifications", formatBridgeMessage(payload));
-    }
-
-    // Push to macOS Reminders (#789). No-op unless
-    // MACOS_REMINDER_NOTIFICATIONS=1 + darwin. Fire-and-forget so a
-    // slow / failing osascript can't block the bell update.
-    void pushToMacosReminder(payload.title, payload.body);
-
-    log.info("notifications", "published", {
-      kind: payload.kind,
-      title: payload.title,
-      id: payload.id,
-    });
-  } catch (err) {
-    // Never let notification failures break the caller (e.g. endRun).
-    log.warn("notifications", "publish failed", { error: String(err) });
+function buildChatTarget(target: Extract<NavigateTarget, { view: typeof NOTIFICATION_VIEWS.chat }>): string | undefined {
+  // No sessionId → drop the action; bouncing off the catch-all
+  // redirect is worse UX than a non-clickable entry. Dot-segment
+  // sessionId would normalize off /chat, so drop too.
+  if (!target.sessionId || !isSafePathComponent(target.sessionId)) return undefined;
+  const sessionPath = `/${PAGE_ROUTES.chat}/${encodeURIComponent(target.sessionId)}`;
+  if (target.resultUuid) return `${sessionPath}?result=${encodeURIComponent(target.resultUuid)}`;
+  return sessionPath;
+}
+
+function buildFilesTarget(target: Extract<NavigateTarget, { view: typeof NOTIFICATION_VIEWS.files }>): string {
+  // Files uses a catch-all (`/files/:pathMatch(.*)`); empty path
+  // lands on the index. Each segment is encoded so spaces / special
+  // characters don't break the URL. A path containing `.` or `..`
+  // segments would normalize out of /files, so refuse to build a
+  // path target for it — the index is the safest fallback.
+  if (!target.path) return `/${PAGE_ROUTES.files}`;
+  const segments = target.path.split("/").filter(Boolean);
+  if (segments.some((segment) => !isSafePathComponent(segment))) return `/${PAGE_ROUTES.files}`;
+  return `/${PAGE_ROUTES.files}/${segments.map(encodeURIComponent).join("/")}`;
+}
+
+function buildWikiTarget(target: Extract<NavigateTarget, { view: typeof NOTIFICATION_VIEWS.wiki }>): string {
+  // Slug rides as a path component → dot-segment-check it. The
+  // anchor lives in the URL fragment, which doesn't participate in
+  // path normalization, so it doesn't need the same guard.
+  const slug = target.slug && isSafePathComponent(target.slug) ? `/pages/${encodeURIComponent(target.slug)}` : "";
+  const hash = target.anchor ? `#${encodeURIComponent(target.anchor)}` : "";
+  return `/${PAGE_ROUTES.wiki}${slug}${hash}`;
+}
+
+function buildSingleSegmentTarget(view: string, segment: string | undefined): string {
+  // Helper for views with a single optional path component: todos
+  // (itemId), automations (taskId), sources (slug). Unsafe values
+  // fall back to the view's index — a soft-fail since these views
+  // all have a usable index page.
+  if (segment && isSafePathComponent(segment)) return `/${view}/${encodeURIComponent(segment)}`;
+  return `/${view}`;
+}
+
+function buildNavigateTarget(target: NavigateTarget): string | undefined {
+  switch (target.view) {
+    case NOTIFICATION_VIEWS.chat:
+      return buildChatTarget(target);
+    case NOTIFICATION_VIEWS.todos:
+      return buildSingleSegmentTarget(PAGE_ROUTES.todos, target.itemId);
+    case NOTIFICATION_VIEWS.calendar:
+      return `/${PAGE_ROUTES.calendar}`;
+    case NOTIFICATION_VIEWS.automations:
+      return buildSingleSegmentTarget(PAGE_ROUTES.automations, target.taskId);
+    case NOTIFICATION_VIEWS.sources:
+      return buildSingleSegmentTarget(PAGE_ROUTES.sources, target.slug);
+    case NOTIFICATION_VIEWS.files:
+      return buildFilesTarget(target);
+    case NOTIFICATION_VIEWS.wiki:
+      return buildWikiTarget(target);
+    default:
+      return undefined;
   }
 }
 
-function formatBridgeMessage(payload: NotificationPayload): string {
-  const icon = payload.kind === NOTIFICATION_KINDS.agent ? "\u2705" : "\u{1F514}";
-  const parts = [icon, payload.title];
-  if (payload.body) parts.push(payload.body);
-  return parts.join(" ");
+/** Flatten a typed `NotificationAction` to a relative URL string the
+ *  bell can hand straight to `router.push`. Returns `undefined` for
+ *  `action: { type: "none" }`, missing required fields (e.g. a chat
+ *  navigate without `sessionId`), or unknown views. The engine's
+ *  `navigateTarget` validation requires same-origin paths starting
+ *  with a single "/", which every branch below satisfies. */
+export function legacyActionToNavigateTarget(action: NotificationAction | undefined): string | undefined {
+  if (!action || action.type !== NOTIFICATION_ACTION_TYPES.navigate) return undefined;
+  return buildNavigateTarget(action.target);
+}
+
+// ── Publish ─────────────────────────────────────────────────────
+
+/**
+ * Host-only entry point for firing notifications.
+ *
+ * **Plugins MUST NOT call this directly.** Plugin code (anything under
+ * `packages/*-plugin/`) MUST publish through `runtime.notifier.publish`
+ * (see `server/notifier/runtime-api.ts`), which auto-binds `pluginPkg`
+ * to the calling plugin so plugins cannot impersonate each other.
+ *
+ * This wrapper exists for host-side callers (`server/agent/`,
+ * `server/api/routes/`, `server/workspace/`, `server/plugins/diagnostics.ts`)
+ * that don't have a `PluginRuntime` to hand. It forwards into
+ * `notifier.publish` with `lifecycle: "fyi"` and stashes legacy fields
+ * on `pluginData` so the bell can preserve icon / i18n / transport
+ * semantics. Bridge + macOS push are owned by separate adapters
+ * subscribed to the `notifier` pubsub channel, not by this function.
+ */
+export function publishNotification(opts: PublishNotificationOpts): void {
+  const legacyId = opts.id ?? makeUuid();
+  const action: NotificationAction = opts.action ?? { type: NOTIFICATION_ACTION_TYPES.none };
+  const pluginData: LegacyNotifierPluginData = {
+    legacy: true,
+    legacyId,
+    kind: opts.kind,
+    priority: opts.priority ?? NOTIFICATION_PRIORITIES.normal,
+    action,
+    i18n: opts.i18n,
+    transportId: opts.transportId,
+    sessionId: opts.sessionId,
+  };
+  // Fire-and-forget — the engine queues writes through its own
+  // coordinator. A persistence failure logs but never throws to the
+  // caller (matches the legacy try/catch contract that protected
+  // call sites like endRun).
+  notifierPublish({
+    pluginPkg: legacyKindToPluginPkg(opts.kind),
+    severity: legacyPriorityToSeverity(opts.priority),
+    lifecycle: "fyi",
+    title: opts.title,
+    body: opts.body,
+    navigateTarget: legacyActionToNavigateTarget(action),
+    pluginData,
+  }).catch((err) => {
+    log.warn("notifications", "publish failed", { error: String(err), legacyId, kind: opts.kind });
+  });
 }
 
 // ── Legacy test notification (kept for PoC endpoint) ────────────
 
 export const DEFAULT_NOTIFICATION_MESSAGE = "Test notification";
 export const DEFAULT_NOTIFICATION_TRANSPORT_ID = "cli";
-export const DEFAULT_NOTIFICATION_CHAT_ID = "notifications";
 
 export interface ScheduleNotificationOptions {
   message?: string;
   body?: string;
   delaySeconds?: number;
   transportId?: string;
-  chatId?: string;
   // Optional deep-link action — lets dev-side callers fire a
   // notification that navigates to a specific permalink when
   // clicked. Without this the fired notification has no click
@@ -140,10 +297,13 @@ export interface ScheduledNotification {
   cancel: () => void;
 }
 
-export function scheduleTestNotification(opts: ScheduleNotificationOptions, legacyDeps: NotificationDeps): ScheduledNotification {
+/** PoC: schedules one `publishNotification` after a delay. Bridge
+ *  push is no longer sent inline here — the bridge adapter (subscribed
+ *  to the notifier channel) fans out to bridges based on the entry's
+ *  `pluginData.transportId`. */
+export function scheduleTestNotification(opts: ScheduleNotificationOptions): ScheduledNotification {
   const message = opts.message ?? DEFAULT_NOTIFICATION_MESSAGE;
   const transportId = opts.transportId ?? DEFAULT_NOTIFICATION_TRANSPORT_ID;
-  const chatId = opts.chatId ?? DEFAULT_NOTIFICATION_CHAT_ID;
   const delaySeconds = clampDelay(opts.delaySeconds);
   const delayMs = delaySeconds * ONE_SECOND_MS;
   const kind = opts.kind ?? NOTIFICATION_KINDS.push;
@@ -156,13 +316,9 @@ export function scheduleTestNotification(opts: ScheduleNotificationOptions, lega
       title: message,
       body: opts.body,
       priority: NOTIFICATION_PRIORITIES.normal,
-      // When the caller supplied an action, pass it through so the
-      // bell clicks into the requested permalink. Otherwise leave
-      // it undefined so publishNotification falls back to the
-      // "navigate: none" default.
       action: opts.action,
+      transportId,
     });
-    legacyDeps.pushToBridge(transportId, chatId, message);
   }, delayMs);
 
   return {

package/server/events/pub-sub/index.ts

@@ -3,7 +3,7 @@ import { Server as IOServer } from "socket.io";
 
 export interface IPubSub {
   /** Publish data to all clients subscribed to this channel. */
-  publish(channel: string, data: unknown): void;
+  publish: (channel: string, data: unknown) => void;
 }
 
 // Channel names are treated as socket.io rooms — one room per