@vibedeckx/darwin-arm64 0.2.15 → 0.2.16

package/dist/bin.js

@@ -13356,12 +13356,12 @@ var require_semver = __commonJS({
     }
     function replaceHyphen(comp, options) {
       const r = HYPHENRANGE_REGEXP;
-      return comp.replace(r, (_3, from, fM, fm, fp32, fpr, fb, to, tM, tm, tp, tpr) => {
+      return comp.replace(r, (_3, from, fM, fm, fp34, fpr, fb, to, tM, tm, tp, tpr) => {
         if (isX(fM)) {
           from = "";
         } else if (isX(fm)) {
           from = `>=${fM}.0.0${options?.includePrerelease ? "-0" : ""}`;
-        } else if (isX(fp32)) {
+        } else if (isX(fp34)) {
           from = `>=${fM}.${fm}.0${options?.includePrerelease ? "-0" : ""}`;
         } else if (fpr) {
           from = `>=${from}`;
@@ -87525,12 +87525,12 @@ var require_range = __commonJS({
       debug("replaceGTE0", comp, options);
       return comp.trim().replace(re2[options.includePrerelease ? t.GTE0PRE : t.GTE0], "");
     };
-    var hyphenReplace = (incPr) => ($0, from, fM, fm, fp32, fpr, fb, to, tM, tm, tp, tpr) => {
+    var hyphenReplace = (incPr) => ($0, from, fM, fm, fp34, fpr, fb, to, tM, tm, tp, tpr) => {
       if (isX(fM)) {
         from = "";
       } else if (isX(fm)) {
         from = `>=${fM}.0.0${incPr ? "-0" : ""}`;
-      } else if (isX(fp32)) {
+      } else if (isX(fp34)) {
         from = `>=${fM}.${fm}.0${incPr ? "-0" : ""}`;
       } else if (fpr) {
         from = `>=${from}`;
@@ -90111,8 +90111,8 @@ var require_pretty_print = __commonJS({
       serializedRoute += serializeMetaData(route.metaData);
       return serializedRoute;
     }
-    function mergeSimilarRoutes(routes31) {
-      return routes31.reduce((mergedRoutes, route) => {
+    function mergeSimilarRoutes(routes33) {
+      return routes33.reduce((mergedRoutes, route) => {
         for (const nodeRoute of mergedRoutes) {
           if (deepEqual(route.opts.constraints, nodeRoute.opts.constraints) && deepEqual(route.metaData, nodeRoute.metaData)) {
             nodeRoute.method += ", " + route.method;
@@ -90124,18 +90124,18 @@ var require_pretty_print = __commonJS({
       }, []);
     }
     function serializeNode(node, prefix, options) {
-      let routes31 = node.routes;
+      let routes33 = node.routes;
       if (options.method === void 0) {
-        routes31 = routes31.map(normalizeRoute);
+        routes33 = routes33.map(normalizeRoute);
       }
-      routes31 = routes31.map((route) => {
+      routes33 = routes33.map((route) => {
         route.metaData = getRouteMetaData(route, options);
         return route;
       });
       if (options.method === void 0) {
-        routes31 = mergeSimilarRoutes(routes31);
+        routes33 = mergeSimilarRoutes(routes33);
       }
-      return routes31.map(serializeRoute).join(`
+      return routes33.map(serializeRoute).join(`
 ${prefix}`);
     }
     function buildObjectTree(node, tree, prefix, options) {
@@ -91402,9 +91402,9 @@ var require_find_my_way = __commonJS({
         pathIndex = paramEndIndex;
       }
     };
-    Router.prototype._rebuild = function(routes31) {
+    Router.prototype._rebuild = function(routes33) {
       this.reset();
-      for (const route of routes31) {
+      for (const route of routes33) {
         const { method, path: path22, opts, handler, store } = route;
         this._on(method, path22, opts, handler, store);
       }
@@ -100612,8 +100612,8 @@ var require_commonjs6 = __commonJS({
           return this.#fullpath = this.name;
         }
         const pv = p2.fullpath();
-        const fp32 = pv + (!p2.parent ? "" : this.sep) + name25;
-        return this.#fullpath = fp32;
+        const fp34 = pv + (!p2.parent ? "" : this.sep) + name25;
+        return this.#fullpath = fp34;
       }
       /**
        * On platforms other than windows, this is identical to fullpath.
@@ -105329,7 +105329,7 @@ var require_static = __commonJS({
     var { fileURLToPath: fileURLToPath4 } = __require("node:url");
     var { statSync: statSync2 } = __require("node:fs");
     var { glob } = require_commonjs7();
-    var fp32 = require_plugin2();
+    var fp34 = require_plugin2();
     var send = require_send2();
     var encodingNegotiator = require_accept_negotiator();
     var contentDisposition = require_content_disposition();
@@ -105433,7 +105433,7 @@ var require_static = __commonJS({
         } else {
           const indexes = new Set(opts.index === void 0 ? ["index.html"] : [].concat(opts.index));
           const indexDirs = /* @__PURE__ */ new Map();
-          const routes31 = /* @__PURE__ */ new Set();
+          const routes33 = /* @__PURE__ */ new Set();
           const roots = Array.isArray(sendOptions.root) ? sendOptions.root : [sendOptions.root];
           for (let rootPath of roots) {
             rootPath = rootPath.split(path22.win32.sep).join(path22.posix.sep);
@@ -105449,10 +105449,10 @@ var require_static = __commonJS({
             for (let file2 of files) {
               file2 = file2.split(path22.win32.sep).join(path22.posix.sep);
               const route = prefix + file2;
-              if (routes31.has(route)) {
+              if (routes33.has(route)) {
                 continue;
               }
-              routes31.add(route);
+              routes33.add(route);
               setUpHeadAndGet(routeOpts, route, `/${file2}`, rootPath);
               const key = path22.posix.basename(route);
               if (indexes.has(key) && !indexDirs.has(key)) {
@@ -105747,7 +105747,7 @@ var require_static = __commonJS({
         throw err;
       }
     }
-    module.exports = fp32(fastifyStatic2, {
+    module.exports = fp34(fastifyStatic2, {
       fastify: "5.x",
       name: "@fastify/static"
     });
@@ -112390,7 +112390,7 @@ var require_websocket2 = __commonJS({
     var { ServerResponse } = __require("node:http");
     var { PassThrough } = __require("node:stream");
     var { randomBytes: randomBytes3 } = __require("node:crypto");
-    var fp32 = require_plugin2();
+    var fp34 = require_plugin2();
     var WebSocket2 = require_ws();
     var Duplexify = require_duplexify();
     var kWs = /* @__PURE__ */ Symbol("ws-socket");
@@ -112576,7 +112576,7 @@ var require_websocket2 = __commonJS({
       }
       next();
     }
-    module.exports = fp32(fastifyWebsocket2, {
+    module.exports = fp34(fastifyWebsocket2, {
       fastify: "5.x",
       name: "@fastify/websocket"
     });
@@ -115020,7 +115020,7 @@ var require_multipart2 = __commonJS({
     "use strict";
     var Busboy = require_main();
     var os2 = __require("node:os");
-    var fp32 = require_plugin2();
+    var fp34 = require_plugin2();
     var { createWriteStream: createWriteStream2 } = __require("node:fs");
     var { unlink: unlink2 } = __require("node:fs/promises");
     var path22 = __require("node:path");
@@ -115469,7 +115469,7 @@ var require_multipart2 = __commonJS({
         }
       });
     }
-    module.exports = fp32(fastifyMultipart2, {
+    module.exports = fp34(fastifyMultipart2, {
       fastify: "5.x",
       name: "@fastify/multipart"
     });
@@ -169019,11 +169019,11 @@ function buildCommand(builderArgs) {
     }
   };
 }
-function* generateRouteMapHelpLines(routes31, docs, args) {
+function* generateRouteMapHelpLines(routes33, docs, args) {
   const { brief, fullDescription, hideRoute } = docs;
   const { headers } = args.text;
   yield args.ansiColor ? `\x1B[1m${headers.usage}\x1B[22m` : headers.usage;
-  for (const [name25, route] of Object.entries(routes31)) {
+  for (const [name25, route] of Object.entries(routes33)) {
     if (!hideRoute || !hideRoute[name25] || args.includeHidden) {
       const externalRouteName = args.config.caseStyle === "convert-camel-to-kebab" ? convertCamelCaseToKebabCase(name25) : name25;
       yield `  ${route.formatUsageLine({
@@ -169053,7 +169053,7 @@ function* generateRouteMapHelpLines(routes31, docs, args) {
   }
   yield "";
   yield args.ansiColor ? `\x1B[1m${headers.commands}\x1B[22m` : headers.commands;
-  const visibleRoutes = Object.entries(routes31).filter(
+  const visibleRoutes = Object.entries(routes33).filter(
     ([name25]) => !hideRoute || !hideRoute[name25] || args.includeHidden
   );
   const rows = visibleRoutes.map(([internalRouteName, route]) => {
@@ -169081,24 +169081,24 @@ function* generateRouteMapHelpLines(routes31, docs, args) {
   }
 }
 function buildRouteMap({
-  routes: routes31,
+  routes: routes33,
   defaultCommand: defaultCommandRoute,
   docs,
   aliases
 }) {
-  if (Object.entries(routes31).length === 0) {
+  if (Object.entries(routes33).length === 0) {
     throw new InternalError("Route map must contain at least one route");
   }
   const activeAliases = aliases ?? {};
   const aliasesByRoute = /* @__PURE__ */ new Map();
   for (const [alias, routeName] of Object.entries(activeAliases)) {
-    if (alias in routes31) {
+    if (alias in routes33) {
       throw new InternalError(`Cannot use "${alias}" as an alias when a route with that name already exists`);
     }
     const routeAliases = aliasesByRoute.get(routeName) ?? [];
     aliasesByRoute.set(routeName, [...routeAliases, alias]);
   }
-  const defaultCommand = defaultCommandRoute ? routes31[defaultCommandRoute] : void 0;
+  const defaultCommand = defaultCommandRoute ? routes33[defaultCommandRoute] : void 0;
   if (defaultCommand && defaultCommand.kind === RouteMapSymbol) {
     throw new InternalError(
       `Cannot use "${defaultCommandRoute}" as the default command because it is not a Command`
@@ -169107,7 +169107,7 @@ function buildRouteMap({
   const resolveRouteName = (input) => {
     if (input in activeAliases) {
       return activeAliases[input];
-    } else if (input in routes31) {
+    } else if (input in routes33) {
       return input;
     }
   };
@@ -169125,7 +169125,7 @@ function buildRouteMap({
       return `${args.prefix.join(" ")} ${routeNames.join("|")} ...`;
     },
     formatHelp: (config2) => {
-      const lines = [...generateRouteMapHelpLines(routes31, docs, config2)];
+      const lines = [...generateRouteMapHelpLines(routes33, docs, config2)];
       const text2 = lines.join("\n");
       return text2 + "\n";
     },
@@ -169168,11 +169168,11 @@ function buildRouteMap({
     },
     getRoutingTargetForInput: (input) => {
       const routeName = input in activeAliases ? activeAliases[input] : input;
-      return routes31[routeName];
+      return routes33[routeName];
     },
     getAllEntries() {
       const hiddenRoutes = docs.hideRoute;
-      return Object.entries(routes31).map(([originalRouteName, target]) => {
+      return Object.entries(routes33).map(([originalRouteName, target]) => {
         return {
           name: {
             original: originalRouteName,
@@ -185055,6 +185055,14 @@ var createCoreRepos = (kdb, h) => ({
       let query = kdb.deleteFrom("projects").where("id", "=", id);
       if (userId) query = query.where("user_id", "=", userId);
       await query.execute();
+    },
+    // Deliberately unscoped: the notification importer runs without a request
+    // context and must DERIVE ownership from the mapped local project rather
+    // than trust any worker-supplied tenant id. Returns "" for solo-mode rows
+    // (the column's default), which callers map to the "local" sentinel.
+    getOwnerId: async (projectId) => {
+      const row = await kdb.selectFrom("projects").select("user_id").where("id", "=", projectId).executeTakeFirst();
+      return row?.user_id;
     }
   },
   settings: {
@@ -185584,6 +185592,15 @@ var createExecutorRepos = (kdb, h) => ({
 });
 
 // src/storage/repositories/agent-sessions.ts
+var mapRemoteSessionMapping = (row) => ({
+  local_session_id: row.local_session_id,
+  project_id: row.project_id,
+  remote_server_id: row.remote_server_id,
+  remote_session_id: row.remote_session_id,
+  branch: row.branch,
+  notification_sync_start: row.notification_sync_start,
+  notification_watch_until: row.notification_watch_until
+});
 var mapAgentSession = (row) => ({
   id: row.id,
   project_id: row.project_id,
@@ -185690,6 +185707,17 @@ var createAgentSessionRepos = (kdb, h) => ({
     upsertEntry: async (sessionId, entryIndex, data) => {
       await kdb.insertInto("agent_session_entries").values({ session_id: sessionId, entry_index: entryIndex, data }).onConflict((oc) => oc.columns(["session_id", "entry_index"]).doUpdateSet({ data })).execute();
     },
+    // One transaction, both writes idempotent — see the contract note in
+    // types.ts for why the milestone must ride with the turn_end rather than
+    // being written next to it.
+    upsertTurnEndWithOutbox: async ({ sessionId, entryIndex, entryData, outbox }) => {
+      await kdb.transaction().execute(async (trx) => {
+        await trx.insertInto("agent_session_entries").values({ session_id: sessionId, entry_index: entryIndex, data: entryData }).onConflict((oc) => oc.columns(["session_id", "entry_index"]).doUpdateSet({ data: entryData })).execute();
+        if (outbox) {
+          await trx.insertInto("notification_outbox").values(outbox).onConflict((oc) => oc.column("id").doNothing()).execute();
+        }
+      });
+    },
     getEntries: async (sessionId) => {
       return kdb.selectFrom("agent_session_entries").select(["entry_index", "data"]).where("session_id", "=", sessionId).orderBy("entry_index", "asc").execute();
     },
@@ -185703,14 +185731,21 @@ var createAgentSessionRepos = (kdb, h) => ({
   remoteSessionMappings: {
     // ON CONFLICT SET deliberately omits title_resolved — a re-upsert (e.g.
     // the remote session getting re-mapped after a reconnect) must not reset
-    // the "AI title already generated" flag back to false.
-    upsert: async (localSessionId, projectId, remoteServerId, remoteSessionId, branch) => {
+    // the "AI title already generated" flag back to false. It omits
+    // notification_sync_start and notification_watch_until for the same reason:
+    // re-mapping a session (reconnect) or reusing a reviewer for a second
+    // review must not downgrade an established from_start policy, and must not
+    // rewind the watch window mid-flight. The sync cursor lives in its own
+    // table and is likewise untouched — a reused reviewer continues from the
+    // boundary it already imported instead of replaying its whole history.
+    upsert: async (localSessionId, projectId, remoteServerId, remoteSessionId, branch, notificationSyncStart) => {
       await kdb.insertInto("remote_session_mappings").values({
         local_session_id: localSessionId,
         project_id: projectId,
         remote_server_id: remoteServerId,
         remote_session_id: remoteSessionId,
-        branch
+        branch,
+        notification_sync_start: notificationSyncStart ?? "from_now"
       }).onConflict((oc) => oc.column("local_session_id").doUpdateSet({
         project_id: projectId,
         remote_server_id: remoteServerId,
@@ -185719,10 +185754,43 @@ var createAgentSessionRepos = (kdb, h) => ({
       })).execute();
     },
     getAll: async () => {
-      return kdb.selectFrom("remote_session_mappings").select(["local_session_id", "project_id", "remote_server_id", "remote_session_id", "branch"]).execute();
+      const rows = await kdb.selectFrom("remote_session_mappings").selectAll().execute();
+      return rows.map(mapRemoteSessionMapping);
+    },
+    getByLocal: async (localSessionId) => {
+      const row = await kdb.selectFrom("remote_session_mappings").selectAll().where("local_session_id", "=", localSessionId).executeTakeFirst();
+      return row ? mapRemoteSessionMapping(row) : void 0;
+    },
+    getByRemote: async (remoteServerId, remoteSessionId) => {
+      const row = await kdb.selectFrom("remote_session_mappings").selectAll().where("remote_server_id", "=", remoteServerId).where("remote_session_id", "=", remoteSessionId).executeTakeFirst();
+      return row ? mapRemoteSessionMapping(row) : void 0;
+    },
+    // MAX(existing, incoming): concurrent extenders (a new turn plus live
+    // stream activity) must not shorten a longer window one of them already set.
+    extendNotificationWatch: async (localSessionId, until) => {
+      await kdb.updateTable("remote_session_mappings").set({
+        notification_watch_until: sql`MAX(COALESCE(notification_watch_until, 0), ${until})`
+      }).where("local_session_id", "=", localSessionId).execute();
     },
+    getNotificationSyncCandidates: async ({ now: now2, includeExpired }) => {
+      let query = kdb.selectFrom("remote_session_mappings").selectAll();
+      if (!includeExpired) {
+        query = query.where("notification_watch_until", ">", now2);
+      }
+      const rows = await query.orderBy("local_session_id", "asc").execute();
+      return rows.map(mapRemoteSessionMapping);
+    },
+    // The cursor is deleted with the mapping: without a mapping the front has
+    // no local target for the worker's events, so a stale cursor would only
+    // suppress a legitimate re-mapping's from_start replay.
     delete: async (localSessionId) => {
-      await kdb.deleteFrom("remote_session_mappings").where("local_session_id", "=", localSessionId).execute();
+      await kdb.transaction().execute(async (trx) => {
+        const row = await trx.selectFrom("remote_session_mappings").select(["remote_server_id", "remote_session_id"]).where("local_session_id", "=", localSessionId).executeTakeFirst();
+        await trx.deleteFrom("remote_session_mappings").where("local_session_id", "=", localSessionId).execute();
+        if (row) {
+          await trx.deleteFrom("notification_sync_cursors").where("remote_server_id", "=", row.remote_server_id).where("remote_session_id", "=", row.remote_session_id).execute();
+        }
+      });
     },
     isTitleResolved: async (localSessionId) => {
       const row = await kdb.selectFrom("remote_session_mappings").select("title_resolved").where("local_session_id", "=", localSessionId).executeTakeFirst();
@@ -186248,6 +186316,18 @@ var createWorkflowRunRepos = (kdb) => ({
     transition: async (id, from, to, patch) => {
       const result = await kdb.updateTable("workflow_runs").set({ ...patch ?? {}, status: to, updated_at: sql`datetime('now')` }).where("id", "=", id).where("status", "=", from).executeTakeFirst();
       return (result.numUpdatedRows ?? 0n) > 0n;
+    },
+    // Guarded update FIRST, then the outbox insert conditioned on it having
+    // applied: that ordering is what makes a lost CAS silent. Both statements
+    // share one transaction so a crash between them can't leave a notified
+    // transition unpersisted (or vice versa).
+    transitionWithOutbox: async (id, from, to, patch, outbox) => {
+      return kdb.transaction().execute(async (trx) => {
+        const result = await trx.updateTable("workflow_runs").set({ ...patch ?? {}, status: to, updated_at: sql`datetime('now')` }).where("id", "=", id).where("status", "=", from).executeTakeFirst();
+        if ((result.numUpdatedRows ?? 0n) === 0n) return false;
+        await trx.insertInto("notification_outbox").values(outbox).onConflict((oc) => oc.column("id").doNothing()).execute();
+        return true;
+      });
     }
   }
 });
@@ -186277,6 +186357,157 @@ var createTurnSnapshotRepos = (kdb) => ({
   }
 });
 
+// src/storage/repositories/notifications.ts
+var mapOutbox = (row) => ({
+  seq: row.seq,
+  id: row.id,
+  kind: row.kind,
+  project_id: row.project_id,
+  branch: row.branch,
+  session_id: row.session_id,
+  workflow_run_id: row.workflow_run_id,
+  created_at: row.created_at
+});
+var mapNotification = (row) => ({
+  id: row.id,
+  user_id: row.user_id,
+  kind: row.kind,
+  project_id: row.project_id,
+  branch: row.branch,
+  session_id: row.session_id,
+  workflow_run_id: row.workflow_run_id,
+  title: row.title,
+  body: row.body,
+  created_at: row.created_at,
+  read_at: row.read_at
+});
+var createNotificationRepos = (kdb) => ({
+  notificationOutbox: {
+    // ON CONFLICT(id) DO NOTHING is what makes retrying the *business*
+    // transition safe: the milestone id is derived from durable state
+    // (session + turn_end index, or workflow run id), so a retried transaction
+    // re-derives the same id and the second insert is a no-op rather than a
+    // second ding. `inserted: false` still returns the existing seq so callers
+    // that want to trigger a drain can do so either way.
+    insert: async (event) => {
+      const result = await kdb.insertInto("notification_outbox").values(event).onConflict((oc) => oc.column("id").doNothing()).executeTakeFirst();
+      const inserted = (result.numInsertedOrUpdatedRows ?? 0n) > 0n;
+      const row = await kdb.selectFrom("notification_outbox").select("seq").where("id", "=", event.id).executeTakeFirst();
+      return { inserted, seq: row?.seq ?? null };
+    },
+    listAfter: async (afterSeq, limit) => {
+      const rows = await kdb.selectFrom("notification_outbox").selectAll().where("seq", ">", afterSeq).orderBy("seq", "asc").limit(limit).execute();
+      return rows.map(mapOutbox);
+    },
+    listBySessionAfter: async (sessionId, afterSeq, limit) => {
+      const rows = await kdb.selectFrom("notification_outbox").selectAll().where("session_id", "=", sessionId).where("seq", ">", afterSeq).orderBy("seq", "asc").limit(limit).execute();
+      return rows.map(mapOutbox);
+    },
+    headBySession: async (sessionId) => {
+      const row = await kdb.selectFrom("notification_outbox").select(kdb.fn.max("seq").as("head")).where("session_id", "=", sessionId).executeTakeFirst();
+      return row?.head ?? 0;
+    },
+    head: async () => {
+      const row = await kdb.selectFrom("notification_outbox").select(kdb.fn.max("seq").as("head")).executeTakeFirst();
+      return row?.head ?? 0;
+    },
+    pruneOlderThan: async (cutoffMs) => {
+      await kdb.deleteFrom("notification_outbox").where("created_at", "<", cutoffMs).execute();
+    }
+  },
+  notifications: {
+    insert: async (notification) => {
+      const result = await kdb.insertInto("notifications").values(notification).onConflict((oc) => oc.column("id").doNothing()).executeTakeFirst();
+      return (result.numInsertedOrUpdatedRows ?? 0n) > 0n;
+    },
+    // One transaction on purpose. Insert-then-crash-then-replay is safe (the id
+    // unique constraint absorbs it), but cursor-advance-then-crash would lose
+    // the notification permanently — so the two writes must commit together.
+    importRemote: async ({ notification, remoteServerId, remoteSessionId, seq }) => {
+      return kdb.transaction().execute(async (trx) => {
+        const result = await trx.insertInto("notifications").values(notification).onConflict((oc) => oc.column("id").doNothing()).executeTakeFirst();
+        await trx.insertInto("notification_sync_cursors").values({
+          remote_server_id: remoteServerId,
+          remote_session_id: remoteSessionId,
+          last_seq: seq,
+          updated_at: Date.now()
+        }).onConflict((oc) => oc.columns(["remote_server_id", "remote_session_id"]).doUpdateSet({
+          // MAX(existing, incoming) — pages can be retried out of order after
+          // a transient remote error, and a cursor that moved backward would
+          // re-import (and re-ding) everything after it.
+          last_seq: sql`MAX(notification_sync_cursors.last_seq, excluded.last_seq)`,
+          updated_at: Date.now()
+        })).execute();
+        return { inserted: (result.numInsertedOrUpdatedRows ?? 0n) > 0n };
+      });
+    },
+    listForUser: async (userId, opts) => {
+      let query = kdb.selectFrom("notifications").selectAll().where("user_id", "=", userId);
+      if (opts.unreadOnly) query = query.where("read_at", "is", null);
+      const rows = await query.orderBy("created_at", "desc").orderBy("id", "desc").limit(opts.limit).execute();
+      return rows.map(mapNotification);
+    },
+    // The user_id predicate is load-bearing authorization, not a filter: a
+    // caller must not be able to mutate — or learn the existence of — another
+    // tenant's notification by guessing its (deterministic, guessable) id.
+    markRead: async (id, userId) => {
+      const result = await kdb.updateTable("notifications").set({ read_at: Date.now() }).where("id", "=", id).where("user_id", "=", userId).where("read_at", "is", null).executeTakeFirst();
+      if ((result.numUpdatedRows ?? 0n) > 0n) return true;
+      const existing = await kdb.selectFrom("notifications").select("id").where("id", "=", id).where("user_id", "=", userId).executeTakeFirst();
+      return existing !== void 0;
+    },
+    markAllRead: async (userId) => {
+      await kdb.updateTable("notifications").set({ read_at: Date.now() }).where("user_id", "=", userId).where("read_at", "is", null).execute();
+    },
+    // Unread rows are never deleted — an unread milestone is the whole point of
+    // the feature. Read history is capped per user so it can't grow forever.
+    cleanup: async (keepRead) => {
+      const users = await kdb.selectFrom("notifications").select("user_id").where("read_at", "is not", null).groupBy("user_id").execute();
+      for (const { user_id } of users) {
+        const keep = await kdb.selectFrom("notifications").select("id").where("user_id", "=", user_id).where("read_at", "is not", null).orderBy("created_at", "desc").orderBy("id", "desc").limit(keepRead).execute();
+        let query = kdb.deleteFrom("notifications").where("user_id", "=", user_id).where("read_at", "is not", null);
+        if (keep.length > 0) {
+          query = query.where("id", "not in", keep.map((r) => r.id));
+        }
+        await query.execute();
+      }
+    }
+  },
+  notificationSyncCursors: {
+    get: async (remoteServerId, remoteSessionId) => {
+      const row = await kdb.selectFrom("notification_sync_cursors").select("last_seq").where("remote_server_id", "=", remoteServerId).where("remote_session_id", "=", remoteSessionId).executeTakeFirst();
+      return row?.last_seq;
+    },
+    getMany: async (remoteServerId, remoteSessionIds) => {
+      if (remoteSessionIds.length === 0) return /* @__PURE__ */ new Map();
+      const rows = await kdb.selectFrom("notification_sync_cursors").select(["remote_session_id", "last_seq"]).where("remote_server_id", "=", remoteServerId).where("remote_session_id", "in", remoteSessionIds).execute();
+      return new Map(rows.map((r) => [r.remote_session_id, r.last_seq]));
+    },
+    set: async (remoteServerId, remoteSessionId, lastSeq) => {
+      await kdb.insertInto("notification_sync_cursors").values({
+        remote_server_id: remoteServerId,
+        remote_session_id: remoteSessionId,
+        last_seq: lastSeq,
+        updated_at: Date.now()
+      }).onConflict((oc) => oc.columns(["remote_server_id", "remote_session_id"]).doUpdateSet({
+        last_seq: sql`MAX(notification_sync_cursors.last_seq, excluded.last_seq)`,
+        updated_at: Date.now()
+      })).execute();
+    },
+    // DO NOTHING, not DO UPDATE: see the contract note in types.ts for why a
+    // baseline must never overwrite an existing cursor.
+    initializeIfAbsent: async (remoteServerId, remoteSessionId, lastSeq) => {
+      const result = await kdb.insertInto("notification_sync_cursors").values({
+        remote_server_id: remoteServerId,
+        remote_session_id: remoteSessionId,
+        last_seq: lastSeq,
+        updated_at: Date.now()
+      }).onConflict((oc) => oc.columns(["remote_server_id", "remote_session_id"]).doNothing()).executeTakeFirst();
+      return (result.numInsertedOrUpdatedRows ?? 0n) > 0n;
+    }
+  }
+});
+
 // src/storage/sqlite.ts
 var createDatabase = (dbPath) => {
   const db = new Database(dbPath);
@@ -186975,7 +187206,66 @@ var createDatabase = (dbPath) => {
       PRIMARY KEY (session_id, turn_end_index),
       FOREIGN KEY (session_id) REFERENCES agent_sessions(id) ON DELETE CASCADE
     );
+
+    -- Durable attention-milestone outbox of THIS server. Written in the same
+    -- transaction as the state that proves the milestone (a turn_end entry, a
+    -- workflow status transition), so a crash can never leave a completed turn
+    -- without its notification. Deliberately carries no title/body: the
+    -- user-facing server generates copy at import time from its own session
+    -- mapping, so a stale worker-side title never enters the wire protocol.
+    -- No FK to agent_sessions: an outbox row must outlive deletion of the
+    -- session it describes (deleting a session mid-sync must not silently drop
+    -- an already-produced milestone). seq is the cursor, not created_at.
+    CREATE TABLE IF NOT EXISTS notification_outbox (
+      seq INTEGER PRIMARY KEY AUTOINCREMENT,
+      id TEXT NOT NULL UNIQUE,
+      kind TEXT NOT NULL,
+      project_id TEXT NOT NULL,
+      branch TEXT,
+      session_id TEXT NOT NULL,
+      workflow_run_id TEXT,
+      created_at INTEGER NOT NULL
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_notification_outbox_session_seq
+      ON notification_outbox(session_id, seq);
+
+    -- User-scoped notification inbox of the user-facing server. The id is the
+    -- deterministic milestone id (remote rows namespaced
+    -- remote:{serverId}:{outboxEventId}), which is what makes replay after a
+    -- crash-before-cursor-advance a no-op instead of a duplicate ding.
+    CREATE TABLE IF NOT EXISTS notifications (
+      id TEXT PRIMARY KEY,
+      user_id TEXT NOT NULL,
+      kind TEXT NOT NULL,
+      project_id TEXT NOT NULL,
+      branch TEXT,
+      session_id TEXT,
+      workflow_run_id TEXT,
+      title TEXT NOT NULL,
+      body TEXT,
+      created_at INTEGER NOT NULL,
+      read_at INTEGER
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_notifications_user_created
+      ON notifications(user_id, created_at DESC);
+
+    CREATE TABLE IF NOT EXISTS notification_sync_cursors (
+      remote_server_id TEXT NOT NULL,
+      remote_session_id TEXT NOT NULL,
+      last_seq INTEGER NOT NULL,
+      updated_at INTEGER NOT NULL,
+      PRIMARY KEY (remote_server_id, remote_session_id)
+    );
   `);
+  const remoteMappingNotifyInfo = db.prepare("PRAGMA table_info(remote_session_mappings)").all();
+  if (!remoteMappingNotifyInfo.some((col) => col.name === "notification_sync_start")) {
+    db.exec("ALTER TABLE remote_session_mappings ADD COLUMN notification_sync_start TEXT NOT NULL DEFAULT 'from_now'");
+  }
+  if (!remoteMappingNotifyInfo.some((col) => col.name === "notification_watch_until")) {
+    db.exec("ALTER TABLE remote_session_mappings ADD COLUMN notification_watch_until INTEGER");
+  }
   const sessionSearchCacheInfo = db.prepare("PRAGMA table_info(session_search_cache)").all();
   if (!sessionSearchCacheInfo.some((col) => col.name === "written_at")) {
     db.exec("ALTER TABLE session_search_cache ADD COLUMN written_at INTEGER");
@@ -187022,6 +187312,7 @@ var createSqliteStorage = async (dbPath) => {
     ...createSearchCacheRepos(kdb, h),
     ...createWorkflowRunRepos(kdb),
     ...createTurnSnapshotRepos(kdb),
+    ...createNotificationRepos(kdb),
     close: async () => {
       await kdb.destroy();
     }
@@ -187038,7 +187329,7 @@ import path17 from "path";
 import { fileURLToPath } from "url";
 
 // src/plugins/shared-services.ts
-var import_fastify_plugin = __toESM(require_plugin2(), 1);
+var import_fastify_plugin2 = __toESM(require_plugin2(), 1);
 
 // src/process-manager.ts
 import { spawn } from "child_process";
@@ -202016,6 +202307,57 @@ import { spawn as spawn3 } from "child_process";
 import { randomUUID } from "crypto";
 import { existsSync as existsSync3 } from "fs";
 
+// src/notification-milestones.ts
+var sessionResultReadyId = (sessionId, turnEndEntryIndex) => `session:${sessionId}:turn:${turnEndEntryIndex}:result-ready`;
+var sessionFailedId = (sessionId, turnEndEntryIndex) => `session:${sessionId}:turn:${turnEndEntryIndex}:failed`;
+var reviewReadyId = (workflowRunId) => `workflow:${workflowRunId}:review-ready`;
+var workflowFailedId = (workflowRunId, stateVersion) => `workflow:${workflowRunId}:failed:${stateVersion}`;
+function findTurnOpeningUserEntry(entries, beforeIndex) {
+  let opening;
+  for (let i = Math.min(beforeIndex, entries.length) - 1; i >= 0; i--) {
+    const entry = entries[i];
+    if (!entry) continue;
+    if (entry.type === "turn_end") break;
+    if (entry.type === "user") opening = entry;
+  }
+  return opening;
+}
+function resolveNotificationDisposition(openingUserEntry) {
+  if (openingUserEntry?.type !== "user") return "result";
+  if (openingUserEntry.notificationDisposition) return openingUserEntry.notificationDisposition;
+  return openingUserEntry.origin === "workflow" ? "internal" : "result";
+}
+var FAILURE_OUTCOMES = /* @__PURE__ */ new Set([
+  "failed",
+  "process_exit",
+  "server_restart"
+]);
+function sessionMilestoneForTurnEnd(opts) {
+  if (opts.disposition !== "result") return void 0;
+  const base = {
+    project_id: opts.projectId,
+    branch: opts.branch,
+    session_id: opts.sessionId,
+    workflow_run_id: null,
+    created_at: opts.createdAt
+  };
+  if (opts.outcome === "completed") {
+    return {
+      ...base,
+      id: sessionResultReadyId(opts.sessionId, opts.entryIndex),
+      kind: "session_result_ready"
+    };
+  }
+  if (FAILURE_OUTCOMES.has(opts.outcome)) {
+    return {
+      ...base,
+      id: sessionFailedId(opts.sessionId, opts.entryIndex),
+      kind: "session_failed"
+    };
+  }
+  return void 0;
+}
+
 // src/utils/cross-remote-token.ts
 import { createHmac, randomBytes, timingSafeEqual } from "crypto";
 var CROSS_REMOTE_SECRET_SETTING = "cross_remote_token_secret";
@@ -224295,6 +224637,36 @@ var AgentSessionManager = class {
   setEventBus(eventBus) {
     this.eventBus = eventBus;
   }
+  /**
+   * Injected by shared-services: nudges NotificationService to drain the local
+   * outbox right after a milestone lands, so the bell is fast in the common
+   * case. Purely a latency optimization — correctness comes from the periodic
+   * and startup drains, because this hook can't fire if the process dies
+   * between the commit and the import.
+   */
+  setMilestoneListener(listener) {
+    this.onMilestoneCreated = listener;
+  }
+  onMilestoneCreated = null;
+  /**
+   * Decide the disposition to persist on an outgoing user turn.
+   *
+   * Ordinary user input defaults to `result`. Workflow callers must be explicit:
+   * `origin: "workflow"` alone is NOT enough to infer `internal`, because
+   * approved review feedback is also a workflow-authored turn yet starts a
+   * user-visible source result. An omission is therefore a caller bug — warn
+   * loudly rather than silently picking a disposition that suppresses a real
+   * notification.
+   */
+  resolveOutgoingDisposition(sessionId, opts) {
+    if (opts?.notificationDisposition) return opts.notificationDisposition;
+    if (opts?.origin === "workflow") {
+      console.warn(
+        `[AgentSession] workflow-origin turn for ${sessionId} carries no explicit notificationDisposition; defaulting to "result"`
+      );
+    }
+    return "result";
+  }
   /**
    * Injected by shared-services: lets commitCompletion mark taskCompleted WS
    * frames whose completion the local WorkflowEngine claims (reviewer
@@ -224570,7 +224942,8 @@ var AgentSessionManager = class {
       bgSpawnHintsThisTurn: 0,
       taskStartedThisTurn: 0,
       lastActiveAt: Date.now(),
-      turnOpenSince: null
+      turnOpenSince: null,
+      turnDisposition: null
     };
     this.sessions.set(sessionId, session);
     const provider = getProvider(agentType);
@@ -225139,14 +225512,22 @@ Details:
 ${details}`;
     return msg;
   }
+  /**
+   * Allocate the next entry index, record the message in the in-memory store,
+   * and build its ADD replay patch. Shared by `pushEntry` and `pushTurnEnd` so
+   * the two persistence paths can't drift on index allocation or patch shape.
+   */
+  stageEntry(session, message) {
+    const index = session.store.indexProvider.next();
+    session.store.entries[index] = message;
+    const patch = ConversationPatch.addEntry(index, message);
+    session.store.patches.push(patch);
+    return { index, patch };
+  }
   async pushEntry(sessionId, message, broadcast = true, userId = "local") {
     const session = this.sessions.get(sessionId);
     if (!session) return -1;
-    const { store } = session;
-    const index = store.indexProvider.next();
-    store.entries[index] = message;
-    const patch = ConversationPatch.addEntry(index, message);
-    store.patches.push(patch);
+    const { index, patch } = this.stageEntry(session, message);
     if (!session.skipDb && message.type !== "assistant") {
       await this.persistEntry(session, index, message, userId);
     }
@@ -225155,6 +225536,60 @@ ${details}`;
     }
     return index;
   }
+  /**
+   * Persist a `turn_end` together with the attention milestone it earns.
+   *
+   * Deliberately NOT routed through `pushEntry`: the milestone id embeds the
+   * turn_end's entry index, so the index has to be allocated before the write,
+   * and the write itself has to be the atomic turn-end/outbox operation rather
+   * than a plain entry upsert. Ordering matches `pushEntry` (persist, then
+   * broadcast) so the existing turn_end-before-status contract still holds.
+   *
+   * `entryIndexOverride` re-persists an already-staged boundary (crash-repair
+   * replay); without it a fresh index is allocated.
+   */
+  async pushTurnEnd(session, outcome, disposition, endedAt, durationMs, entryIndexOverride) {
+    const message = {
+      type: "turn_end",
+      timestamp: endedAt,
+      ...durationMs !== void 0 ? { durationMs } : {},
+      outcome,
+      notificationDisposition: disposition
+    };
+    let index;
+    let patch;
+    if (entryIndexOverride !== void 0) {
+      index = entryIndexOverride;
+      patch = ConversationPatch.addEntry(index, message);
+    } else {
+      ({ index, patch } = this.stageEntry(session, message));
+    }
+    if (!session.skipDb) {
+      const outbox = sessionMilestoneForTurnEnd({
+        sessionId: session.id,
+        projectId: session.projectId,
+        branch: session.branch,
+        entryIndex: index,
+        outcome,
+        disposition,
+        createdAt: endedAt
+      });
+      try {
+        await this.storage.agentSessions.upsertTurnEndWithOutbox({
+          sessionId: session.id,
+          entryIndex: index,
+          entryData: JSON.stringify(message),
+          outbox
+        });
+        await this.storage.agentSessions.touchUpdatedAt(session.id);
+        if (outbox) this.onMilestoneCreated?.();
+      } catch (error48) {
+        console.error(`[AgentSession] Failed to persist turn_end ${index} for ${session.id}:`, error48);
+      }
+    }
+    if (entryIndexOverride === void 0) this.broadcastPatch(session.id, patch);
+    return index;
+  }
   /**
    * Persist a single entry to the database
    */
@@ -225193,18 +225628,24 @@ ${details}`;
     }
   }
   /**
-   * Close the open turn with a persisted turn_end stop-point entry.
+   * Close the open turn with a persisted turn_end stop-point entry, plus the
+   * attention milestone the turn's disposition earns (written in the same
+   * storage transaction — see pushTurnEnd).
+   *
    * turn_end entries are constructed ONLY here and in repairInterruptedTurn
    * (restore path). Wall clock only — see design doc for why the CLI's
-   * payload.duration_ms is not used. Rides the normal best-effort entry
-   * persistence on purpose (no strict path — design decision).
+   * payload.duration_ms is not used.
    */
   async endActiveTurn(session, outcome) {
     if (session.turnOpenSince === null) return null;
     const endedAt = Date.now();
     const durationMs = endedAt - session.turnOpenSince;
-    const index = await this.pushEntry(session.id, { type: "turn_end", timestamp: endedAt, durationMs, outcome }, true);
+    const disposition = session.turnDisposition ?? resolveNotificationDisposition(
+      findTurnOpeningUserEntry(session.store.entries, session.store.entries.length)
+    );
+    const index = await this.pushTurnEnd(session, outcome, disposition, endedAt, durationMs);
     session.turnOpenSince = null;
+    session.turnDisposition = null;
     if (!session.skipDb && index >= 0) {
       try {
         const project = await this.storage.projects.getById(session.projectId);
@@ -225223,12 +225664,13 @@ ${details}`;
   async sendUserMessage(sessionId, content, projectPath, userId = "local", opts) {
     const session = this.sessions.get(sessionId);
     if (!session) return false;
+    const disposition = this.resolveOutgoingDisposition(sessionId, opts);
     if (session.dormant) {
       if (!projectPath) {
         console.error(`[AgentSession] Cannot wake dormant session ${sessionId} without projectPath`);
         return false;
       }
-      await this.wakeDormantSession(session, projectPath, content, userId, opts?.origin);
+      await this.wakeDormantSession(session, projectPath, content, userId, opts?.origin, disposition);
       return true;
     }
     if (!session.process?.stdin) {
@@ -225248,7 +225690,8 @@ ${details}`;
       type: "user",
       content,
       timestamp: Date.now(),
-      ...opts?.origin ? { origin: opts.origin } : {}
+      ...opts?.origin ? { origin: opts.origin } : {},
+      notificationDisposition: disposition
     }, true, userId);
     try {
       const provider = getProvider(session.agentType);
@@ -225257,14 +225700,20 @@ ${details}`;
         console.warn(
           `[AgentSession] sendUserMessage: provider buffered the input for ${session.agentType} session ${sessionId} \u2014 no stdin payload yet`
         );
-        if (session.turnOpenSince === null) session.turnOpenSince = Date.now();
+        if (session.turnOpenSince === null) {
+          session.turnOpenSince = Date.now();
+          session.turnDisposition = disposition;
+        }
         return true;
       }
       console.log(
         `[AgentSession] sendUserMessage: wrote ${formatted.length}B to ${session.agentType} stdin (session=${sessionId})`
       );
       session.process.stdin.write(formatted);
-      if (session.turnOpenSince === null) session.turnOpenSince = Date.now();
+      if (session.turnOpenSince === null) {
+        session.turnOpenSince = Date.now();
+        session.turnDisposition = disposition;
+      }
       return true;
     } catch (error48) {
       console.error(`[AgentSession] Failed to send message:`, error48);
@@ -225691,7 +226140,7 @@ ${details}`;
   /**
    * Wake a dormant session: spawn process, send full context + user message
    */
-  async wakeDormantSession(session, projectPath, userMessage, userId = "local", origin) {
+  async wakeDormantSession(session, projectPath, userMessage, userId = "local", origin, notificationDisposition = "result") {
     console.log(`[AgentSession] Waking dormant session ${session.id}`);
     await this.ensureResidentCapacity(
       { projectId: session.projectId, branch: session.branch },
@@ -225712,9 +226161,11 @@ ${details}`;
       type: "user",
       content: userMessage,
       timestamp: Date.now(),
-      ...origin ? { origin } : {}
+      ...origin ? { origin } : {},
+      notificationDisposition
     }, true, userId);
     session.turnOpenSince = Date.now();
+    session.turnDisposition = notificationDisposition;
     setTimeout(() => {
       const context2 = this.buildFullConversationContext(session.store.entries);
       if (context2) {
@@ -225781,7 +226232,8 @@ ${details}`;
    * this runs on server boot for every restored session and must never
    * throw into the restore path.
    */
-  async repairInterruptedTurn(sessionId, rows) {
+  async repairInterruptedTurn(dbSession, rows) {
+    const sessionId = dbSession.id;
     let landingType = null;
     for (let i = rows.length - 1; i >= 0; i--) {
       try {
@@ -225796,17 +226248,43 @@ ${details}`;
     if (landingType === null || landingType === "turn_end") return rows;
     const maxIndex = rows.reduce((m2, r) => Math.max(m2, r.entry_index), -1);
     const repairIndex = maxIndex + 1;
-    const repair = { type: "turn_end", timestamp: Date.now(), outcome: "server_restart" };
+    const entries = [];
+    for (const row of rows) {
+      try {
+        entries[row.entry_index] = JSON.parse(row.data);
+      } catch {
+      }
+    }
+    const disposition = resolveNotificationDisposition(
+      findTurnOpeningUserEntry(entries, repairIndex)
+    );
+    const repair = {
+      type: "turn_end",
+      timestamp: Date.now(),
+      outcome: "server_restart",
+      notificationDisposition: disposition
+    };
     const data = JSON.stringify(repair);
-    await this.storage.agentSessions.upsertEntry(sessionId, repairIndex, data);
-    console.log(`[AgentSession] Repaired interrupted turn for ${sessionId} (server_restart turn_end at ${repairIndex})`);
+    const outbox = sessionMilestoneForTurnEnd({
+      sessionId,
+      projectId: dbSession.project_id,
+      branch: dbSession.branch || null,
+      entryIndex: repairIndex,
+      outcome: "server_restart",
+      disposition,
+      createdAt: repair.timestamp
+    });
+    await this.storage.agentSessions.upsertTurnEndWithOutbox({
+      sessionId,
+      entryIndex: repairIndex,
+      entryData: data,
+      outbox
+    });
+    console.log(`[AgentSession] Repaired interrupted turn for ${sessionId} (server_restart turn_end at ${repairIndex}, disposition=${disposition})`);
     try {
-      const dbSession = await this.storage.agentSessions.getById(sessionId);
-      if (dbSession) {
-        const project = await this.storage.projects.getById(dbSession.project_id);
-        if (project?.path) {
-          await recordTurnSnapshot(this.storage, sessionId, repairIndex, resolveWorktreePath(project.path, dbSession.branch));
-        }
+      const project = await this.storage.projects.getById(dbSession.project_id);
+      if (project?.path) {
+        await recordTurnSnapshot(this.storage, sessionId, repairIndex, resolveWorktreePath(project.path, dbSession.branch));
       }
     } catch (error48) {
       console.warn(`[AgentSession] Turn snapshot lookup failed for ${sessionId}@${repairIndex}:`, error48);
@@ -225825,7 +226303,7 @@ ${details}`;
       let entries = await this.storage.agentSessions.getEntries(dbSession.id);
       if (entries.length === 0) continue;
       if (dbSession.status === "running") {
-        entries = await this.repairInterruptedTurn(dbSession.id, entries);
+        entries = await this.repairInterruptedTurn(dbSession, entries);
       }
       const store = this.rebuildStoreFromRows(entries, dbSession.id);
       const permissionMode = dbSession.permission_mode === "plan" ? "plan" : "edit";
@@ -225848,7 +226326,8 @@ ${details}`;
         bgSpawnHintsThisTurn: 0,
         taskStartedThisTurn: 0,
         lastActiveAt: Date.now(),
-        turnOpenSince: null
+        turnOpenSince: null,
+        turnDisposition: null
       };
       this.sessions.set(dbSession.id, runningSession);
       await this.storage.agentSessions.updateStatusPreservingTimestamp(dbSession.id, "stopped");
@@ -225950,6 +226429,7 @@ ${details}`;
       taskStartedThisTurn: 0,
       lastActiveAt: Date.now(),
       turnOpenSince: null,
+      turnDisposition: null,
       crossRemoteMcp: opts.crossRemoteMcp
     };
     this.sessions.set(newId, branched);
@@ -226296,6 +226776,394 @@ function runUpdatedEventFromRemoteFrame(parsed, sessionId, remoteInfo) {
   return { type: "workflow:run-updated", projectId, branch: run2.branch, run: run2 };
 }
 
+// src/routes/notification-outbox-routes.ts
+var import_fastify_plugin = __toESM(require_plugin2(), 1);
+var MAX_SESSIONS_PER_REQUEST = 100;
+var MAX_EVENTS_PER_SESSION = 100;
+function validateOutboxQuery(body) {
+  const raw = body?.sessions;
+  if (!Array.isArray(raw)) return { ok: false, error: "sessions must be an array" };
+  if (raw.length === 0) return { ok: false, error: "sessions must not be empty" };
+  if (raw.length > MAX_SESSIONS_PER_REQUEST) {
+    return { ok: false, error: `sessions must contain at most ${MAX_SESSIONS_PER_REQUEST} entries` };
+  }
+  const seen = /* @__PURE__ */ new Set();
+  const sessions = [];
+  for (const entry of raw) {
+    if (typeof entry !== "object" || entry === null) return { ok: false, error: "each session must be an object" };
+    const { sessionId, after, headOnly } = entry;
+    if (typeof sessionId !== "string" || sessionId.length === 0) {
+      return { ok: false, error: "sessionId must be a non-empty string" };
+    }
+    if (typeof after !== "number" || !Number.isInteger(after) || after < 0) {
+      return { ok: false, error: "after must be a non-negative integer" };
+    }
+    if (headOnly !== void 0 && typeof headOnly !== "boolean") {
+      return { ok: false, error: "headOnly must be a boolean" };
+    }
+    if (seen.has(sessionId)) return { ok: false, error: `duplicate sessionId: ${sessionId}` };
+    seen.add(sessionId);
+    sessions.push({ sessionId, after, ...headOnly ? { headOnly: true } : {} });
+  }
+  const rawLimit = body?.limitPerSession;
+  if (rawLimit !== void 0) {
+    if (typeof rawLimit !== "number" || !Number.isInteger(rawLimit) || rawLimit <= 0) {
+      return { ok: false, error: "limitPerSession must be a positive integer" };
+    }
+    if (rawLimit > MAX_EVENTS_PER_SESSION) {
+      return { ok: false, error: `limitPerSession must be at most ${MAX_EVENTS_PER_SESSION}` };
+    }
+  }
+  return {
+    ok: true,
+    sessions,
+    limit: typeof rawLimit === "number" ? rawLimit : MAX_EVENTS_PER_SESSION
+  };
+}
+var routes = async (fastify2) => {
+  fastify2.post("/api/notification-outbox/query", async (req, reply) => {
+    const authResult = requireAuth(req, reply);
+    if (authResult === null) return;
+    const validated = validateOutboxQuery(req.body ?? {});
+    if (!validated.ok) return reply.code(400).send({ error: validated.error });
+    const sessions = [];
+    for (const request of validated.sessions) {
+      const headCursor = await fastify2.storage.notificationOutbox.headBySession(request.sessionId);
+      if (request.headOnly) {
+        sessions.push({
+          sessionId: request.sessionId,
+          events: [],
+          headCursor,
+          nextCursor: headCursor,
+          hasMore: false
+        });
+        continue;
+      }
+      const events = await fastify2.storage.notificationOutbox.listBySessionAfter(
+        request.sessionId,
+        request.after,
+        validated.limit
+      );
+      const nextCursor = events.length > 0 ? events[events.length - 1].seq : request.after;
+      sessions.push({
+        sessionId: request.sessionId,
+        events,
+        headCursor,
+        nextCursor,
+        hasMore: nextCursor < headCursor
+      });
+    }
+    return reply.code(200).send({ sessions });
+  });
+};
+var notification_outbox_routes_default = (0, import_fastify_plugin.default)(routes, { name: "notification-outbox-routes" });
+
+// src/remote-notification-sync.ts
+var OUTBOX_QUERY_PATH = "/api/notification-outbox/query";
+var QUERY_TIMEOUT_MS = 15e3;
+var WATCH_WINDOW_MS = 30 * 60 * 1e3;
+var WATCH_EXTEND_THROTTLE_MS = 5 * 60 * 1e3;
+var MAX_TRACKED_SESSIONS = 5e3;
+var SYNC_INTERVAL_MS = 6e4;
+var MAX_PAGES_PER_SYNC = 50;
+function localWorkflowRunId(remoteServerId, projectId, remoteRunId) {
+  return `remote-${remoteServerId}-${projectId}-${remoteRunId}`;
+}
+function localNotificationId(remoteServerId, outboxEventId) {
+  return `remote:${remoteServerId}:${outboxEventId}`;
+}
+var RemoteNotificationSync = class {
+  storage;
+  notificationService;
+  reverseConnectManager;
+  proxy;
+  timer = null;
+  stopped = false;
+  /** Serializes sweeps so a came-online sweep can't interleave with the tick. */
+  chain = Promise.resolve();
+  /**
+   * Remote sessions this front currently believes are RUNNING. They are polled
+   * regardless of their persisted watch window: an agent turn can easily run
+   * longer than WATCH_WINDOW_MS while emitting nothing the bus can see, and a
+   * mapping that lapsed mid-turn would not be polled when the turn finally
+   * produces its milestone.
+   */
+  activeRemoteSessions = /* @__PURE__ */ new Set();
+  /** sessionId → last activity-driven watch extension (see WATCH_EXTEND_THROTTLE_MS). */
+  lastWatchExtend = /* @__PURE__ */ new Map();
+  constructor(deps) {
+    this.storage = deps.storage;
+    this.notificationService = deps.notificationService;
+    this.reverseConnectManager = deps.reverseConnectManager;
+    this.proxy = deps.proxy ?? proxyToRemoteAuto;
+  }
+  start() {
+    if (this.timer || this.stopped) return;
+    this.timer = setInterval(() => {
+      this.enqueue(() => this.syncAll({ includeExpired: false }));
+    }, SYNC_INTERVAL_MS);
+    this.timer.unref?.();
+  }
+  shutdown() {
+    this.stopped = true;
+    if (this.timer) clearInterval(this.timer);
+    this.timer = null;
+    this.activeRemoteSessions.clear();
+    this.lastWatchExtend.clear();
+  }
+  /**
+   * Watch live remote activity (design §Mapping initialization and polling).
+   *
+   * The bus carries the remote stream's bridged `session:status` /
+   * `session:taskCompleted` frames plus this front's own emits for remote
+   * sessions, so it is the one place that sees a remote session start and stop
+   * without threading a callback through the WebSocket plumbing.
+   */
+  setEventBus(bus) {
+    bus.subscribe((event) => this.observeActivity(event));
+  }
+  observeActivity(event) {
+    const sessionId = event.sessionId;
+    if (!sessionId || !sessionId.startsWith("remote-")) return;
+    if (event.type === "session:status") {
+      if (event.status === "running") this.activeRemoteSessions.add(sessionId);
+      else this.activeRemoteSessions.delete(sessionId);
+    } else if (event.type === "session:taskCompleted" || event.type === "session:finished") {
+      this.activeRemoteSessions.delete(sessionId);
+    }
+    const now2 = Date.now();
+    const last = this.lastWatchExtend.get(sessionId) ?? 0;
+    if (now2 - last < WATCH_EXTEND_THROTTLE_MS) return;
+    if (this.lastWatchExtend.size >= MAX_TRACKED_SESSIONS) this.pruneWatchBookkeeping(now2);
+    this.lastWatchExtend.set(sessionId, now2);
+    void this.extendWatch(sessionId);
+  }
+  /** Drop throttle entries older than a full window — they can only re-extend. */
+  pruneWatchBookkeeping(now2) {
+    for (const [sessionId, at] of this.lastWatchExtend) {
+      if (now2 - at > WATCH_WINDOW_MS) this.lastWatchExtend.delete(sessionId);
+    }
+  }
+  /** Fire-and-forget sweep, queued behind any in-flight one. */
+  enqueue(work) {
+    if (this.stopped) return;
+    this.chain = this.chain.then(work).catch((err) => console.warn("[RemoteNotifications] sync failed:", err));
+  }
+  /** Extend a mapping's periodic-poll window (create / send / workflow start / live activity). */
+  async extendWatch(localSessionId) {
+    await this.storage.remoteSessionMappings.extendNotificationWatch(localSessionId, Date.now() + WATCH_WINDOW_MS).catch((err) => console.warn(`[RemoteNotifications] extendWatch(${localSessionId}) failed:`, err));
+  }
+  /**
+   * Called before this front starts a new turn on a remote session.
+   *
+   * For a `from_now` mapping that has never been initialized, this records the
+   * worker's current head FIRST — otherwise the turn we are about to start could
+   * finish, be seen as "at or below the head we later record", and be suppressed
+   * as history. Returns false when the baseline could not be recorded, in which
+   * case the caller must NOT start the turn.
+   */
+  async prepareForNewTurn(localSessionId) {
+    const mapping = await this.storage.remoteSessionMappings.getByLocal(localSessionId);
+    if (!mapping) return true;
+    await this.extendWatch(localSessionId);
+    if (mapping.notification_sync_start !== "from_now") return true;
+    const existing = await this.storage.notificationSyncCursors.get(
+      mapping.remote_server_id,
+      mapping.remote_session_id
+    );
+    if (existing !== void 0) return true;
+    const target = await this.resolveTarget(mapping);
+    if (!target) {
+      console.warn(`[RemoteNotifications] no remote link for ${localSessionId}; skipping baseline`);
+      return true;
+    }
+    const result = await this.query(target, [{ sessionId: mapping.remote_session_id, after: 0, headOnly: true }]);
+    if (!result.ok) {
+      console.warn(
+        `[RemoteNotifications] baseline for ${localSessionId} failed (status ${result.status}); refusing to start the turn`
+      );
+      return false;
+    }
+    const sessions = this.parseSessions(result);
+    const head = sessions.find((s3) => s3.sessionId === mapping.remote_session_id)?.headCursor;
+    if (head === void 0) {
+      console.warn(`[RemoteNotifications] baseline response for ${localSessionId} omitted the session`);
+      return false;
+    }
+    await this.storage.notificationSyncCursors.initializeIfAbsent(
+      mapping.remote_server_id,
+      mapping.remote_session_id,
+      head
+    );
+    return true;
+  }
+  /** Sweep every mapped remote server. */
+  async syncAll(opts) {
+    const mappings = await this.candidates(opts);
+    for (const [serverId, group2] of groupByServer(mappings)) {
+      await this.syncMappings(serverId, group2);
+    }
+  }
+  /** Sweep one server — used when a reverse connection comes online. */
+  async syncServer(remoteServerId, opts) {
+    const mappings = (await this.candidates(opts)).filter((m2) => m2.remote_server_id === remoteServerId);
+    if (mappings.length > 0) await this.syncMappings(remoteServerId, mappings);
+  }
+  /**
+   * Mappings this sweep should poll: the persisted watch set, plus any session
+   * currently believed to be running.
+   *
+   * The union is what keeps a turn longer than WATCH_WINDOW_MS covered. Its
+   * window is extended when the turn starts, but a long turn can go silent for
+   * hours; without this the mapping would lapse out of the periodic set and its
+   * eventual milestone would wait for a server restart or a remote reconnect.
+   */
+  async candidates(opts) {
+    const mappings = await this.storage.remoteSessionMappings.getNotificationSyncCandidates({
+      now: Date.now(),
+      includeExpired: opts.includeExpired
+    });
+    if (opts.includeExpired || this.activeRemoteSessions.size === 0) return mappings;
+    const present = new Set(mappings.map((m2) => m2.local_session_id));
+    for (const localSessionId of this.activeRemoteSessions) {
+      if (present.has(localSessionId)) continue;
+      const mapping = await this.storage.remoteSessionMappings.getByLocal(localSessionId);
+      if (mapping) mappings.push(mapping);
+    }
+    return mappings;
+  }
+  async syncMappings(remoteServerId, mappings) {
+    for (let i = 0; i < mappings.length; i += MAX_SESSIONS_PER_REQUEST) {
+      const chunk = mappings.slice(i, i + MAX_SESSIONS_PER_REQUEST);
+      await this.syncChunk(remoteServerId, chunk).catch(
+        (err) => console.warn(`[RemoteNotifications] chunk sync for ${remoteServerId} failed:`, err)
+      );
+    }
+  }
+  async syncChunk(remoteServerId, chunk) {
+    const target = await this.resolveTarget(chunk[0]);
+    if (!target) {
+      console.warn(`[RemoteNotifications] no remote link for server ${remoteServerId}; skipping ${chunk.length} mapping(s)`);
+      return;
+    }
+    let pending = new Map(chunk.map((m2) => [m2.remote_session_id, m2]));
+    for (let page = 0; page < MAX_PAGES_PER_SYNC && pending.size > 0; page++) {
+      const cursors = await this.storage.notificationSyncCursors.getMany(
+        remoteServerId,
+        [...pending.keys()]
+      );
+      const requests = [...pending.values()].map((mapping) => {
+        const cursor = cursors.get(mapping.remote_session_id);
+        if (mapping.notification_sync_start === "from_now" && cursor === void 0) {
+          return { sessionId: mapping.remote_session_id, after: 0, headOnly: true };
+        }
+        return { sessionId: mapping.remote_session_id, after: cursor ?? 0 };
+      });
+      const result = await this.query(target, requests);
+      if (!result.ok) {
+        console.warn(`[RemoteNotifications] outbox query to ${remoteServerId} failed (status ${result.status})`);
+        return;
+      }
+      const byId = new Map(this.parseSessions(result).map((s3) => [s3.sessionId, s3]));
+      const next = /* @__PURE__ */ new Map();
+      for (const request of requests) {
+        const mapping = pending.get(request.sessionId);
+        const session = byId.get(request.sessionId);
+        if (!session) continue;
+        if ("headOnly" in request && request.headOnly) {
+          await this.storage.notificationSyncCursors.initializeIfAbsent(
+            remoteServerId,
+            mapping.remote_session_id,
+            session.headCursor
+          );
+          continue;
+        }
+        const imported = await this.importSession(remoteServerId, mapping, session);
+        if (imported && session.hasMore) next.set(request.sessionId, mapping);
+      }
+      pending = next;
+    }
+  }
+  /**
+   * Import one session's page. Returns false when the batch was rejected, in
+   * which case its cursor is untouched.
+   */
+  async importSession(remoteServerId, mapping, session) {
+    for (const event of session.events) {
+      if (event.session_id !== mapping.remote_session_id) {
+        console.warn(
+          `[RemoteNotifications] ${remoteServerId}: event ${event.id} claims session ${event.session_id}, expected ${mapping.remote_session_id}; rejecting batch`
+        );
+        return false;
+      }
+    }
+    const ownerId = await this.storage.projects.getOwnerId(mapping.project_id);
+    if (ownerId === void 0) {
+      console.warn(`[RemoteNotifications] project ${mapping.project_id} not found; skipping ${mapping.local_session_id}`);
+      return false;
+    }
+    for (const event of session.events) {
+      const notification = await this.notificationService.buildNotification(event, {
+        id: localNotificationId(remoteServerId, event.id),
+        userId: ownerId || "local",
+        projectId: mapping.project_id,
+        sessionId: mapping.local_session_id,
+        workflowRunId: event.workflow_run_id ? localWorkflowRunId(remoteServerId, mapping.project_id, event.workflow_run_id) : null
+      });
+      const { inserted } = await this.storage.notifications.importRemote({
+        notification,
+        remoteServerId,
+        remoteSessionId: mapping.remote_session_id,
+        seq: event.seq
+      });
+      if (inserted) this.notificationService.emitCreated(notification);
+    }
+    if (session.events.length > 0) await this.extendWatch(mapping.local_session_id);
+    return true;
+  }
+  async query(target, sessions) {
+    return this.proxy(
+      target.serverId,
+      target.url,
+      target.apiKey,
+      "POST",
+      OUTBOX_QUERY_PATH,
+      { sessions, limitPerSession: MAX_EVENTS_PER_SESSION },
+      { timeoutMs: QUERY_TIMEOUT_MS, reverseConnectManager: this.reverseConnectManager }
+    );
+  }
+  parseSessions(result) {
+    const sessions = result.data?.sessions;
+    return Array.isArray(sessions) ? sessions : [];
+  }
+  /**
+   * URL/apiKey come from project_remotes — the authoritative source, same as the
+   * remoteSessionMap hydration in shared-services. Reverse-connect rows have an
+   * empty URL and are routed by server id instead.
+   */
+  async resolveTarget(mapping) {
+    const remote = await this.storage.projectRemotes.getByProjectAndServer(
+      mapping.project_id,
+      mapping.remote_server_id
+    );
+    if (!remote) return null;
+    return {
+      serverId: mapping.remote_server_id,
+      url: remote.server_url ?? "",
+      apiKey: remote.server_api_key || ""
+    };
+  }
+};
+function groupByServer(mappings) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const mapping of mappings) {
+    const existing = groups.get(mapping.remote_server_id);
+    if (existing) existing.push(mapping);
+    else groups.set(mapping.remote_server_id, [mapping]);
+  }
+  return groups;
+}
+
 // src/remote-agent-sessions.ts
 async function createRemoteAgentSession(deps, params) {
   const { projectId, agentMode, remoteConfig, branch, permissionMode, agentType, force, userId } = params;
@@ -226332,7 +227200,8 @@ async function createRemoteAgentSession(deps, params) {
       deps.remoteSessionMap.delete(localSessionId);
       return { ok: false, status: 409, data: { error: "Remote returned an unexpected session id; upgrade the remote" } };
     }
-    await deps.remoteSessionMappings.upsert(localSessionId, projectId, agentMode, remoteSessionId, branch ?? null);
+    await deps.remoteSessionMappings.upsert(localSessionId, projectId, agentMode, remoteSessionId, branch ?? null, "from_start");
+    await deps.remoteSessionMappings.extendNotificationWatch(localSessionId, Date.now() + WATCH_WINDOW_MS).catch((err) => console.warn("[RemoteSession] notification watch extend failed:", err));
     await deps.storage.searchCache.noteSessionCreated({
       localSessionId,
       projectId,
@@ -228975,6 +229844,15 @@ var WorkflowError = class extends Error {
   }
   code;
 };
+var TERMINAL_STATUSES = /* @__PURE__ */ new Set(["completed", "cancelled", "failed"]);
+var REVIEWER_TURN = {
+  origin: "workflow",
+  notificationDisposition: "milestone-managed"
+};
+var FEEDBACK_TURN = {
+  origin: "workflow",
+  notificationDisposition: "result"
+};
 var MAX_CONTEXT_CHARS = 2e3;
 var MAX_SELF_REPORT_CHARS = 4e3;
 var SELF_REPORT_MIN_CHARS = 80;
@@ -229170,10 +230048,57 @@ var WorkflowEngine = class {
       if (participant.runId === runId) this.participants.delete(sid);
     }
   }
+  /**
+   * The single place a run becomes `failed`. Goes through a guarded transition
+   * out of the run's CURRENT status rather than an unconditional status write,
+   * so the failure milestone can only be created by the caller that actually
+   * performed the transition — a run that concurrently completed or was
+   * cancelled fails the CAS and writes nothing.
+   *
+   * The milestone targets the participant the user should inspect: the reviewer
+   * when one exists, otherwise the source session (a run can fail before its
+   * reviewer is ever created).
+   */
   async failRun(run2, error48) {
-    const failed = await this.storage.workflowRuns.update(run2.id, { status: "failed", error: error48 });
+    if (TERMINAL_STATUSES.has(run2.status)) return;
+    const from = run2.status;
+    const ok = await this.storage.workflowRuns.transitionWithOutbox(
+      run2.id,
+      from,
+      "failed",
+      { error: error48 },
+      {
+        // The state the run failed OUT OF: two distinct failures of one run are
+        // distinct attention milestones, while a retried transition out of the
+        // same state is not.
+        id: workflowFailedId(run2.id, from),
+        kind: "workflow_failed",
+        project_id: run2.project_id,
+        branch: run2.branch,
+        session_id: run2.reviewer_session_id ?? run2.source_session_id,
+        workflow_run_id: run2.id,
+        created_at: Date.now()
+      }
+    );
+    if (!ok) return;
+    const failed = await this.storage.workflowRuns.getById(run2.id);
     if (failed) this.untrackRun(failed);
+    this.onMilestoneCreated?.();
+  }
+  /** Test seam for the failure path (see failRun). */
+  async failRunForTest(runId, error48) {
+    const run2 = await this.storage.workflowRuns.getById(runId);
+    if (run2) await this.failRun(run2, error48);
   }
+  /**
+   * Injected by shared-services: nudges NotificationService to drain the local
+   * outbox promptly. Latency only — correctness rests on the periodic/startup
+   * drains, since this can't fire if the process dies right after the commit.
+   */
+  setMilestoneListener(listener) {
+    this.onMilestoneCreated = listener;
+  }
+  onMilestoneCreated = null;
   /** Sync check used by ChatSessionManager before waking the commander model. */
   shouldSuppressAgentEvent(sessionId) {
     return this.participants.get(sessionId)?.role === "reviewer";
@@ -229299,7 +230224,7 @@ var WorkflowEngine = class {
           reviewFocus: opts.reviewFocus ?? null,
           target
         });
-        const sent = await this.agentOps.sendUserMessage(opts.reviewerSessionId, prompt, opts.project.path, void 0, { origin: "workflow" }).catch(() => false);
+        const sent = await this.agentOps.sendUserMessage(opts.reviewerSessionId, prompt, opts.project.path, void 0, REVIEWER_TURN).catch(() => false);
         if (!sent) {
           await this.failRun(run2, "\u5411\u4E0A\u6B21 reviewer \u6295\u9012\u590D\u5BA1\u4EFB\u52A1\u5931\u8D25");
           throw new WorkflowError("send-failed", "\u5411\u4E0A\u6B21 reviewer \u6295\u9012\u590D\u5BA1\u4EFB\u52A1\u5931\u8D25");
@@ -229344,13 +230269,9 @@ var WorkflowEngine = class {
           target,
           scope
         });
-        const sent = await this.agentOps.sendUserMessage(reviewerId, prompt, opts.project.path, void 0, { origin: "workflow" });
+        const sent = await this.agentOps.sendUserMessage(reviewerId, prompt, opts.project.path, void 0, REVIEWER_TURN);
         if (!sent) {
-          const failed = await this.storage.workflowRuns.update(run2.id, {
-            status: "failed",
-            error: "\u5411 reviewer \u6295\u9012\u4EFB\u52A1\u5931\u8D25"
-          });
-          if (failed) this.untrackRun(failed);
+          await this.failRun({ ...run2, reviewer_session_id: reviewerId }, "\u5411 reviewer \u6295\u9012\u4EFB\u52A1\u5931\u8D25");
           throw new WorkflowError("spawn-failed", "\u5411 reviewer \u6295\u9012\u4EFB\u52A1\u5931\u8D25");
         }
         const updated = await this.storage.workflowRuns.update(run2.id, { reviewer_session_id: reviewerId });
@@ -229359,11 +230280,7 @@ var WorkflowEngine = class {
         return updated;
       } catch (err) {
         if (err instanceof WorkflowError && err.code === "spawn-failed") throw err;
-        const failed = await this.storage.workflowRuns.update(run2.id, {
-          status: "failed",
-          error: `\u521B\u5EFA reviewer \u5931\u8D25\uFF1A${err instanceof Error ? err.message : String(err)}`
-        });
-        if (failed) this.untrackRun(failed);
+        await this.failRun(run2, `\u521B\u5EFA reviewer \u5931\u8D25\uFF1A${err instanceof Error ? err.message : String(err)}`);
         throw new WorkflowError("spawn-failed", "\u521B\u5EFA reviewer session \u5931\u8D25");
       }
     } catch (err) {
@@ -229388,11 +230305,28 @@ var WorkflowEngine = class {
       }
     } catch {
     }
-    const ok = await this.storage.workflowRuns.transition(run2.id, "waiting_reviewer", "waiting_feedback", {
-      feedback_snapshot: feedback,
-      ...driftNote ? { error: driftNote } : {}
-    });
+    const ok = await this.storage.workflowRuns.transitionWithOutbox(
+      run2.id,
+      "waiting_reviewer",
+      "waiting_feedback",
+      {
+        feedback_snapshot: feedback,
+        ...driftNote ? { error: driftNote } : {}
+      },
+      {
+        id: reviewReadyId(run2.id),
+        kind: "review_ready",
+        project_id: run2.project_id,
+        branch: run2.branch,
+        // Target the reviewer: that's where the feedback and the
+        // approve/discard controls are.
+        session_id: event.sessionId,
+        workflow_run_id: run2.id,
+        created_at: Date.now()
+      }
+    );
     if (!ok) return;
+    this.onMilestoneCreated?.();
     const updated = await this.storage.workflowRuns.getById(run2.id);
     if (updated) this.emitRunUpdated(updated);
   }
@@ -229409,7 +230343,7 @@ var WorkflowEngine = class {
     if (!claimed) throw new WorkflowError("bad-state", "run \u72B6\u6001\u5DF2\u53D8\u5316\uFF08\u53EF\u80FD\u5DF2\u88AB\u5904\u7406\uFF09");
     const feedback = editedPayload ?? run2.feedback_snapshot ?? "";
     const project = await this.storage.projects.getById(run2.project_id);
-    const ok = await this.agentOps.sendUserMessage(run2.source_session_id, buildFeedbackMessage(feedback), project?.path ?? void 0, void 0, { origin: "workflow" }).catch(() => false);
+    const ok = await this.agentOps.sendUserMessage(run2.source_session_id, buildFeedbackMessage(feedback), project?.path ?? void 0, void 0, FEEDBACK_TURN).catch(() => false);
     if (!ok) {
       await this.storage.workflowRuns.transition(runId, "sending_feedback", "waiting_feedback", {
         error: "\u53D1\u9001\u5931\u8D25\uFF1A\u76EE\u6807 session \u53EF\u80FD\u672A\u8FD0\u884C\u3002\u8BF7\u5728\u5176\u7A97\u53E3\u4E2D\u5524\u9192\u540E\u91CD\u8BD5\uFF0C\u6216\u7ED3\u675F\u672C\u6B21 review\u3002"
@@ -229430,7 +230364,7 @@ var WorkflowEngine = class {
   async cancelRun(runId, reason) {
     const run2 = await this.storage.workflowRuns.getById(runId);
     if (!run2) return void 0;
-    if (["completed", "cancelled", "failed"].includes(run2.status)) return run2;
+    if (TERMINAL_STATUSES.has(run2.status)) return run2;
     const patch = reason ? { error: reason } : void 0;
     const cancelled = await this.storage.workflowRuns.transition(runId, "waiting_reviewer", "cancelled", patch) || await this.storage.workflowRuns.transition(runId, "waiting_feedback", "cancelled", patch);
     if (!cancelled) {
@@ -231244,6 +232178,154 @@ var SchedulerService = class {
   }
 };
 
+// src/notification-service.ts
+var TITLE_BY_KIND = {
+  review_ready: "Review feedback is ready",
+  session_result_ready: "Session result is ready",
+  session_failed: "Session failed",
+  workflow_failed: "Workflow needs attention"
+};
+var PLACEHOLDER_TITLES = /* @__PURE__ */ new Set(["New Session", "Generating title\u2026", "Generating title..."]);
+var LOCAL_CURSOR_KEY = "notification_local_cursor";
+var OUTBOX_PAGE_SIZE = 100;
+var READ_HISTORY_PER_USER = 500;
+var OUTBOX_RETENTION_DAYS = 90;
+var DRAIN_INTERVAL_MS = 3e4;
+var CLEANUP_INTERVAL_MS = 6 * 60 * 60 * 1e3;
+function notificationBody(opts) {
+  const title = opts.sessionTitle?.trim();
+  if (title && !PLACEHOLDER_TITLES.has(title)) return title;
+  if (opts.branch) return opts.branch;
+  return opts.projectName?.trim() || null;
+}
+function notificationTitle(kind) {
+  return TITLE_BY_KIND[kind] ?? "Update";
+}
+var NotificationService = class {
+  constructor(storage, eventBus) {
+    this.storage = storage;
+    this.eventBus = eventBus;
+  }
+  storage;
+  eventBus;
+  drainTimer = null;
+  cleanupTimer = null;
+  /** Serializes drains so a nudge can't interleave with the periodic tick. */
+  drainChain = Promise.resolve();
+  stopped = false;
+  /**
+   * Start the background timers. Unref'd: a pending drain must never be the
+   * reason a CLI process refuses to exit.
+   */
+  start() {
+    if (this.drainTimer || this.stopped) return;
+    this.drainTimer = setInterval(() => this.requestDrain(), DRAIN_INTERVAL_MS);
+    this.drainTimer.unref?.();
+    this.cleanupTimer = setInterval(() => {
+      void this.cleanup().catch((err) => console.warn("[Notifications] cleanup failed:", err));
+    }, CLEANUP_INTERVAL_MS);
+    this.cleanupTimer.unref?.();
+  }
+  shutdown() {
+    this.stopped = true;
+    if (this.drainTimer) clearInterval(this.drainTimer);
+    if (this.cleanupTimer) clearInterval(this.cleanupTimer);
+    this.drainTimer = null;
+    this.cleanupTimer = null;
+  }
+  /**
+   * Fire-and-forget nudge used right after a milestone lands, so the bell is
+   * fast in the common case. Queued behind any in-flight drain.
+   */
+  requestDrain() {
+    if (this.stopped) return;
+    this.drainChain = this.drainChain.then(() => this.drainLocal()).catch((err) => console.warn("[Notifications] local drain failed:", err));
+  }
+  /**
+   * Import every local outbox event after the durable cursor.
+   *
+   * The cursor advances per page AFTER its rows are inserted, so a crash
+   * mid-drain replays the page — harmless, because insertion is idempotent on
+   * the milestone id and `notification:created` is only emitted for rows this
+   * call actually inserted.
+   */
+  async drainLocal() {
+    for (; ; ) {
+      const cursor = await this.readLocalCursor();
+      const events = await this.storage.notificationOutbox.listAfter(cursor, OUTBOX_PAGE_SIZE);
+      if (events.length === 0) return;
+      for (const event of events) {
+        await this.importLocalEvent(event);
+      }
+      await this.storage.settings.set(LOCAL_CURSOR_KEY, String(events[events.length - 1].seq));
+      if (events.length < OUTBOX_PAGE_SIZE) return;
+    }
+  }
+  async importLocalEvent(event) {
+    const ownerId = await this.storage.projects.getOwnerId(event.project_id);
+    if (ownerId === void 0) {
+      console.warn(`[Notifications] dropping outbox event ${event.id}: project ${event.project_id} not found`);
+      return;
+    }
+    const notification = await this.buildNotification(event, {
+      id: event.id,
+      // "" is the solo-mode column default; the browser routes read the
+      // "local" sentinel, so normalize here rather than in every query.
+      userId: ownerId || "local",
+      sessionId: event.session_id,
+      projectId: event.project_id,
+      workflowRunId: event.workflow_run_id
+    });
+    if (await this.storage.notifications.insert(notification)) {
+      this.eventBus.emit({ type: "notification:created", projectId: notification.project_id, notification });
+    }
+  }
+  /**
+   * Assemble the persisted row. `ids` is separate from the event because remote
+   * imports substitute front-local identities (see RemoteNotificationSync) while
+   * reusing this exact copy generation.
+   */
+  async buildNotification(event, ids) {
+    const session = ids.sessionId ? await this.storage.agentSessions.getById(ids.sessionId) : void 0;
+    const project = await this.storage.projects.getById(ids.projectId);
+    return {
+      id: ids.id,
+      user_id: ids.userId,
+      kind: event.kind,
+      project_id: ids.projectId,
+      branch: event.branch,
+      session_id: ids.sessionId,
+      workflow_run_id: ids.workflowRunId,
+      title: notificationTitle(event.kind),
+      body: notificationBody({
+        sessionTitle: session?.title,
+        branch: event.branch,
+        projectName: project?.name
+      }),
+      created_at: event.created_at,
+      read_at: null
+    };
+  }
+  /** Emit for a row a remote import just inserted. */
+  emitCreated(notification) {
+    this.eventBus.emit({ type: "notification:created", projectId: notification.project_id, notification });
+  }
+  /** Retention: cap read history per user, prune aged worker outbox rows. */
+  async cleanup() {
+    await this.storage.notifications.cleanup(READ_HISTORY_PER_USER);
+    await this.storage.notificationOutbox.pruneOlderThan(Date.now() - OUTBOX_RETENTION_DAYS * 864e5);
+  }
+  async readLocalCursor() {
+    const raw = await this.storage.settings.get(LOCAL_CURSOR_KEY);
+    const parsed = raw === void 0 ? 0 : Number(raw);
+    return Number.isFinite(parsed) && parsed >= 0 ? parsed : 0;
+  }
+  /** Simulates a crash between inbox insertion and cursor commit. */
+  async resetLocalCursorForTest() {
+    await this.storage.settings.set(LOCAL_CURSOR_KEY, "0");
+  }
+};
+
 // src/plugins/shared-services.ts
 var sharedServices = async (fastify2, opts) => {
   const processManager = new ProcessManager(opts.storage);
@@ -231382,8 +232464,25 @@ var sharedServices = async (fastify2, opts) => {
   fastify2.decorate("browserManager", browserManager);
   fastify2.decorate("scheduler", scheduler);
   agentSessionManager.setEventBus(eventBus);
+  const notificationService = new NotificationService(opts.storage, eventBus);
+  fastify2.decorate("notificationService", notificationService);
+  agentSessionManager.setMilestoneListener(() => notificationService.requestDrain());
+  const remoteNotificationSync = new RemoteNotificationSync({
+    storage: opts.storage,
+    notificationService,
+    reverseConnectManager
+  });
+  fastify2.decorate("remoteNotificationSync", remoteNotificationSync);
+  remoteNotificationSync.setEventBus(eventBus);
+  reverseConnectManager.setStatusChangeHandler((remoteServerId, status) => {
+    if (status !== "online") return;
+    remoteNotificationSync.enqueue(
+      () => remoteNotificationSync.syncServer(remoteServerId, { includeExpired: true })
+    );
+  });
   const workflowEngine = new WorkflowEngine(opts.storage, agentSessionManager);
   workflowEngine.setEventBus(eventBus);
+  workflowEngine.setMilestoneListener(() => notificationService.requestDrain());
   await workflowEngine.init();
   fastify2.decorate("workflowEngine", workflowEngine);
   chatSessionManager.setWorkflowEngine(workflowEngine);
@@ -231393,6 +232492,10 @@ var sharedServices = async (fastify2, opts) => {
   processManager.setEventBus(eventBus);
   scheduler.setEventBus(eventBus);
   await scheduler.start();
+  notificationService.start();
+  notificationService.requestDrain();
+  remoteNotificationSync.start();
+  remoteNotificationSync.enqueue(() => remoteNotificationSync.syncAll({ includeExpired: true }));
   void (async () => {
     const savedRows = await opts.storage.remoteExecutorProcesses.getRunning();
     const directUrlRows = savedRows.filter((r) => r.remote_url);
@@ -231408,6 +232511,8 @@ var sharedServices = async (fastify2, opts) => {
   });
   fastify2.addHook("onClose", async () => {
     scheduler.shutdown();
+    notificationService.shutdown();
+    remoteNotificationSync.shutdown();
     agentSessionManager.shutdown();
     processManager.shutdown();
     remotePatchCache.shutdown();
@@ -231416,10 +232521,10 @@ var sharedServices = async (fastify2, opts) => {
     await browserManager.shutdown();
   });
 };
-var shared_services_default = (0, import_fastify_plugin.default)(sharedServices, { name: "shared-services" });
+var shared_services_default = (0, import_fastify_plugin2.default)(sharedServices, { name: "shared-services" });
 
 // src/routes/project-routes.ts
-var import_fastify_plugin2 = __toESM(require_plugin2(), 1);
+var import_fastify_plugin3 = __toESM(require_plugin2(), 1);
 import path8 from "path";
 import { randomUUID as randomUUID9 } from "crypto";
 import { exec as exec2 } from "child_process";
@@ -231472,7 +232577,7 @@ function sanitizeProject(project) {
   const { remote_api_key, ...safe } = project;
   return { ...safe, has_remote_api_key: !!remote_api_key };
 }
-var routes = async (fastify2) => {
+var routes2 = async (fastify2) => {
   fastify2.get("/api/projects", async (req, reply) => {
     const userId = requireAuth(req, reply);
     if (userId === null) return;
@@ -231734,12 +232839,12 @@ var routes = async (fastify2) => {
     }
   });
 };
-var project_routes_default = (0, import_fastify_plugin2.default)(routes, { name: "project-routes" });
+var project_routes_default = (0, import_fastify_plugin3.default)(routes2, { name: "project-routes" });
 
 // src/routes/remote-routes.ts
-var import_fastify_plugin3 = __toESM(require_plugin2(), 1);
+var import_fastify_plugin4 = __toESM(require_plugin2(), 1);
 import { randomUUID as randomUUID10 } from "crypto";
-var routes2 = async (fastify2) => {
+var routes3 = async (fastify2) => {
   fastify2.post("/api/remote/test-connection", async (req, reply) => {
     const { url: url2, apiKey } = req.body;
     if (!url2 || !apiKey) {
@@ -231791,17 +232896,17 @@ var routes2 = async (fastify2) => {
     return reply.code(201).send({ project: safeProject });
   });
 };
-var remote_routes_default = (0, import_fastify_plugin3.default)(routes2, { name: "remote-routes" });
+var remote_routes_default = (0, import_fastify_plugin4.default)(routes3, { name: "remote-routes" });
 
 // src/routes/remote-server-routes.ts
-var import_fastify_plugin4 = __toESM(require_plugin2(), 1);
+var import_fastify_plugin5 = __toESM(require_plugin2(), 1);
 function sanitizeServer(server) {
   const { api_key: _3, connect_token: _t, ...safe } = server;
   return safe;
 }
 var CROSS_REMOTE_ACCESS_VALUES = ["off", "read", "exec"];
 var isCrossRemoteAccess = (value) => typeof value === "string" && CROSS_REMOTE_ACCESS_VALUES.includes(value);
-var routes3 = async (fastify2) => {
+var routes4 = async (fastify2) => {
   fastify2.get("/api/remote-servers", async (request, reply) => {
     const userId = requireAuth(request, reply);
     if (userId === null) return;
@@ -231986,15 +233091,15 @@ var routes3 = async (fastify2) => {
     }
   );
 };
-var remote_server_routes_default = (0, import_fastify_plugin4.default)(routes3, { name: "remote-server-routes" });
+var remote_server_routes_default = (0, import_fastify_plugin5.default)(routes4, { name: "remote-server-routes" });
 
 // src/routes/project-remote-routes.ts
-var import_fastify_plugin5 = __toESM(require_plugin2(), 1);
+var import_fastify_plugin6 = __toESM(require_plugin2(), 1);
 function sanitizeProjectRemote(pr) {
   const { server_api_key: _3, ...safe } = pr;
   return safe;
 }
-var routes4 = async (fastify2) => {
+var routes5 = async (fastify2) => {
   fastify2.get(
     "/api/projects/:id/remotes",
     async (request, reply) => {
@@ -232088,12 +233193,12 @@ var routes4 = async (fastify2) => {
     }
   );
 };
-var project_remote_routes_default = (0, import_fastify_plugin5.default)(routes4, { name: "project-remote-routes" });
+var project_remote_routes_default = (0, import_fastify_plugin6.default)(routes5, { name: "project-remote-routes" });
 
 // src/routes/executor-group-routes.ts
-var import_fastify_plugin6 = __toESM(require_plugin2(), 1);
+var import_fastify_plugin7 = __toESM(require_plugin2(), 1);
 import { randomUUID as randomUUID11 } from "crypto";
-var routes5 = async (fastify2) => {
+var routes6 = async (fastify2) => {
   fastify2.get(
     "/api/projects/:projectId/executor-groups",
     async (req, reply) => {
@@ -232164,17 +233269,17 @@ var routes5 = async (fastify2) => {
     }
   );
 };
-var executor_group_routes_default = (0, import_fastify_plugin6.default)(routes5, { name: "executor-group-routes" });
+var executor_group_routes_default = (0, import_fastify_plugin7.default)(routes6, { name: "executor-group-routes" });
 
 // src/routes/executor-routes.ts
-var import_fastify_plugin7 = __toESM(require_plugin2(), 1);
+var import_fastify_plugin8 = __toESM(require_plugin2(), 1);
 import { randomUUID as randomUUID12 } from "crypto";
 function normalizeSqlTimestamp(value) {
   if (!value) return null;
   if (value.includes("T") && /(Z|[+-]\d{2}:?\d{2})$/.test(value)) return value;
   return value.replace(" ", "T") + "Z";
 }
-var routes6 = async (fastify2) => {
+var routes7 = async (fastify2) => {
   fastify2.get(
     "/api/projects/:projectId/executors",
     async (req, reply) => {
@@ -232313,13 +233418,13 @@ var routes6 = async (fastify2) => {
     return reply.code(200).send({ success: true });
   });
 };
-var executor_routes_default = (0, import_fastify_plugin7.default)(routes6, { name: "executor-routes" });
+var executor_routes_default = (0, import_fastify_plugin8.default)(routes7, { name: "executor-routes" });
 
 // src/routes/process-routes.ts
-var import_fastify_plugin8 = __toESM(require_plugin2(), 1);
+var import_fastify_plugin9 = __toESM(require_plugin2(), 1);
 import path9 from "path";
 import { randomUUID as randomUUID13 } from "crypto";
-var routes7 = async (fastify2) => {
+var routes8 = async (fastify2) => {
   fastify2.post("/api/path/execute", async (req, reply) => {
     const { path: projectPath, command, executor_type, prompt_provider, cwd, branch, pty: pty2 } = req.body;
     if (!projectPath || !command) {
@@ -232529,10 +233634,10 @@ var routes7 = async (fastify2) => {
     return reply.code(200).send({ processes });
   });
 };
-var process_routes_default = (0, import_fastify_plugin8.default)(routes7, { name: "process-routes" });
+var process_routes_default = (0, import_fastify_plugin9.default)(routes8, { name: "process-routes" });
 
 // src/routes/worktree-routes.ts
-var import_fastify_plugin9 = __toESM(require_plugin2(), 1);
+var import_fastify_plugin10 = __toESM(require_plugin2(), 1);
 import { mkdir as mkdir3 } from "fs/promises";
 async function getAllRemoteConfigs(fastify2, project) {
   const remotes = await fastify2.storage.projectRemotes.getByProject(project.id);
@@ -232558,7 +233663,7 @@ async function getRemoteConfig(fastify2, project) {
   const all = await getAllRemoteConfigs(fastify2, project);
   return all.length > 0 ? all[0] : null;
 }
-var routes8 = async (fastify2) => {
+var routes9 = async (fastify2) => {
   fastify2.get("/api/path/branches", async (req, reply) => {
     const projectPath = req.query.path;
     if (!projectPath) {
@@ -233096,10 +234201,10 @@ var routes8 = async (fastify2) => {
     });
   });
 };
-var worktree_routes_default = (0, import_fastify_plugin9.default)(routes8, { name: "worktree-routes" });
+var worktree_routes_default = (0, import_fastify_plugin10.default)(routes9, { name: "worktree-routes" });
 
 // src/routes/diff-routes.ts
-var import_fastify_plugin10 = __toESM(require_plugin2(), 1);
+var import_fastify_plugin11 = __toESM(require_plugin2(), 1);
 import path10 from "path";
 import { readFileSync as readFileSync4 } from "fs";
 import { execFileSync as execFileSync5 } from "child_process";
@@ -233419,7 +234524,7 @@ async function getUntrackedFiles(cwd) {
   }
   return files;
 }
-var routes9 = async (fastify2) => {
+var routes10 = async (fastify2) => {
   fastify2.get("/api/path/diff", async (req, reply) => {
     const projectPath = req.query.path;
     if (!projectPath) {
@@ -233614,10 +234719,10 @@ var routes9 = async (fastify2) => {
     }
   });
 };
-var diff_routes_default = (0, import_fastify_plugin10.default)(routes9, { name: "diff-routes" });
+var diff_routes_default = (0, import_fastify_plugin11.default)(routes10, { name: "diff-routes" });
 
 // src/routes/file-routes.ts
-var import_fastify_plugin11 = __toESM(require_plugin2(), 1);
+var import_fastify_plugin12 = __toESM(require_plugin2(), 1);
 import path11 from "path";
 import fs2 from "fs/promises";
 import { createReadStream, constants as fsConstants } from "fs";
@@ -233853,7 +234958,7 @@ async function searchSymbol(basePath33, symbol26) {
   }
   return { hits, truncated };
 }
-var routes10 = async (fastify2) => {
+var routes11 = async (fastify2) => {
   fastify2.get("/api/path/browse", async (req, reply) => {
     const projectPath = req.query.path;
     if (!projectPath) {
@@ -234447,10 +235552,10 @@ var routes10 = async (fastify2) => {
     }
   });
 };
-var file_routes_default = (0, import_fastify_plugin11.default)(routes10, { name: "file-routes" });
+var file_routes_default = (0, import_fastify_plugin12.default)(routes11, { name: "file-routes" });
 
 // src/routes/agent-session-routes.ts
-var import_fastify_plugin12 = __toESM(require_plugin2(), 1);
+var import_fastify_plugin13 = __toESM(require_plugin2(), 1);
 
 // src/utils/paste-file.ts
 import { chmod, mkdir as mkdir4, open } from "node:fs/promises";
@@ -234498,7 +235603,7 @@ function messageTextLength(content) {
   }
   return n;
 }
-var routes11 = async (fastify2) => {
+var routes12 = async (fastify2) => {
   function proxyAuto(remoteServerId, remoteUrl, remoteApiKey, method, apiPath, body) {
     return proxyToRemoteAuto(remoteServerId, remoteUrl, remoteApiKey, method, apiPath, body, {
       reverseConnectManager: fastify2.reverseConnectManager
@@ -234756,7 +235861,8 @@ var routes11 = async (fastify2) => {
             project.id,
             project.agent_mode,
             s3.id,
-            s3.branch ?? null
+            s3.branch ?? null,
+            "from_now"
           );
           return { ...s3, id: localSessionId, processAlive: s3.processAlive ?? false, entry_count: s3.entry_count ?? 0 };
         }));
@@ -234851,7 +235957,8 @@ var routes11 = async (fastify2) => {
             project.id,
             agentMode,
             remoteData.session.id,
-            branch ?? null
+            branch ?? null,
+            "from_now"
           );
           if (remoteData.messages && remoteData.messages.length > 0) {
             const cacheEntry = fastify2.remotePatchCache.getOrCreate(localSessionId);
@@ -235078,6 +236185,12 @@ var routes11 = async (fastify2) => {
         console.log(`[API] /message 404: remote session not found. Known keys: [${[...fastify2.remoteSessionMap.keys()].join(", ")}]`);
         return reply.code(404).send({ error: "Remote session not found" });
       }
+      if (!await fastify2.remoteNotificationSync.prepareForNewTurn(req.params.sessionId)) {
+        return reply.code(502).send({
+          error: "Could not reach the remote server to prepare notification delivery",
+          errorCode: "notification_baseline_failed"
+        });
+      }
       const result = await proxyAuto(
         remoteInfo.remoteServerId,
         remoteInfo.remoteUrl,
@@ -235332,7 +236445,8 @@ var routes11 = async (fastify2) => {
             projectId,
             remoteInfo.remoteServerId,
             newRemoteSessionId,
-            remoteInfo.branch ?? null
+            remoteInfo.branch ?? null,
+            "from_start"
           );
           await fastify2.storage.remoteSessionMappings.markTitleResolved(localSessionId);
           fastify2.agentSessionManager.markTitleResolved(localSessionId);
@@ -235627,10 +236741,10 @@ var routes11 = async (fastify2) => {
     return reply.code(200).send({ success: true, favorited });
   });
 };
-var agent_session_routes_default = (0, import_fastify_plugin12.default)(routes11, { name: "agent-session-routes" });
+var agent_session_routes_default = (0, import_fastify_plugin13.default)(routes12, { name: "agent-session-routes" });
 
 // src/routes/branch-activity-routes.ts
-var import_fastify_plugin13 = __toESM(require_plugin2(), 1);
+var import_fastify_plugin14 = __toESM(require_plugin2(), 1);
 function toResponse(map2) {
   return {
     branches: Array.from(map2.entries()).map(([branch, state]) => ({
@@ -235645,7 +236759,7 @@ function fromResponse(resp) {
     resp.branches.map((b2) => [b2.branch ?? "", { activity: b2.activity, since: b2.since }])
   );
 }
-var routes12 = async (fastify2) => {
+var routes13 = async (fastify2) => {
   function proxyAuto(remoteServerId, remoteUrl, remoteApiKey, method, apiPath, body) {
     return proxyToRemoteAuto(remoteServerId, remoteUrl, remoteApiKey, method, apiPath, body, {
       reverseConnectManager: fastify2.reverseConnectManager
@@ -235712,10 +236826,10 @@ var routes12 = async (fastify2) => {
     }
   );
 };
-var branch_activity_routes_default = (0, import_fastify_plugin13.default)(routes12, { name: "branch-activity-routes" });
+var branch_activity_routes_default = (0, import_fastify_plugin14.default)(routes13, { name: "branch-activity-routes" });
 
 // src/routes/merge-status-routes.ts
-var import_fastify_plugin14 = __toESM(require_plugin2(), 1);
+var import_fastify_plugin15 = __toESM(require_plugin2(), 1);
 function resolveTargets(comparisons, storedTargets) {
   const sources = [];
   const effective = comparisons.map((comparison) => {
@@ -235849,7 +236963,7 @@ function sendComputed(reply, repoPath, comparisons, repository) {
     return reply.code(statusCode).send({ error: message });
   }
 }
-var routes13 = async (fastify2) => {
+var routes14 = async (fastify2) => {
   fastify2.post(
     "/api/path/branches/merge-status",
     async (req, reply) => {
@@ -235973,11 +237087,11 @@ var routes13 = async (fastify2) => {
     }
   );
 };
-var merge_status_routes_default = (0, import_fastify_plugin14.default)(routes13, { name: "merge-status-routes" });
+var merge_status_routes_default = (0, import_fastify_plugin15.default)(routes14, { name: "merge-status-routes" });
 
 // src/routes/chat-session-routes.ts
-var import_fastify_plugin15 = __toESM(require_plugin2(), 1);
-var routes14 = async (fastify2) => {
+var import_fastify_plugin16 = __toESM(require_plugin2(), 1);
+var routes15 = async (fastify2) => {
   const getAuthorizedSession = (req, reply, sessionId) => {
     const authResult = requireAuth(req, reply);
     if (authResult === null) return null;
@@ -236082,12 +237196,12 @@ var routes14 = async (fastify2) => {
     return reply.send({ ok: true });
   });
 };
-var chat_session_routes_default = (0, import_fastify_plugin15.default)(routes14, { name: "chat-session-routes" });
+var chat_session_routes_default = (0, import_fastify_plugin16.default)(routes15, { name: "chat-session-routes" });
 
 // src/routes/task-routes.ts
-var import_fastify_plugin16 = __toESM(require_plugin2(), 1);
+var import_fastify_plugin17 = __toESM(require_plugin2(), 1);
 import { randomUUID as randomUUID16 } from "crypto";
-var routes15 = async (fastify2) => {
+var routes16 = async (fastify2) => {
   fastify2.get(
     "/api/projects/:projectId/tasks",
     async (req, reply) => {
@@ -236233,12 +237347,12 @@ Description: ${description}`,
     return reply.code(200).send({ success: true });
   });
 };
-var task_routes_default = (0, import_fastify_plugin16.default)(routes15, { name: "task-routes" });
+var task_routes_default = (0, import_fastify_plugin17.default)(routes16, { name: "task-routes" });
 
 // src/routes/rule-routes.ts
-var import_fastify_plugin17 = __toESM(require_plugin2(), 1);
+var import_fastify_plugin18 = __toESM(require_plugin2(), 1);
 import { randomUUID as randomUUID17 } from "crypto";
-var routes16 = async (fastify2) => {
+var routes17 = async (fastify2) => {
   fastify2.get(
     "/api/projects/:projectId/rules",
     async (req, reply) => {
@@ -236324,12 +237438,12 @@ var routes16 = async (fastify2) => {
     return reply.code(200).send({ success: true });
   });
 };
-var rule_routes_default = (0, import_fastify_plugin17.default)(routes16, { name: "rule-routes" });
+var rule_routes_default = (0, import_fastify_plugin18.default)(routes17, { name: "rule-routes" });
 
 // src/routes/command-routes.ts
-var import_fastify_plugin18 = __toESM(require_plugin2(), 1);
+var import_fastify_plugin19 = __toESM(require_plugin2(), 1);
 import { randomUUID as randomUUID18 } from "crypto";
-var routes17 = async (fastify2) => {
+var routes18 = async (fastify2) => {
   fastify2.get(
     "/api/projects/:projectId/commands",
     async (req, reply) => {
@@ -236398,10 +237512,10 @@ var routes17 = async (fastify2) => {
     return reply.code(200).send({ success: true });
   });
 };
-var command_routes_default = (0, import_fastify_plugin18.default)(routes17, { name: "command-routes" });
+var command_routes_default = (0, import_fastify_plugin19.default)(routes18, { name: "command-routes" });
 
 // src/routes/workflow-run-routes.ts
-var import_fastify_plugin19 = __toESM(require_plugin2(), 1);
+var import_fastify_plugin20 = __toESM(require_plugin2(), 1);
 
 // src/utils/review-brief.ts
 var AI_TIMEOUT_MS2 = 15e3;
@@ -236515,7 +237629,7 @@ function errStatus(err) {
       return 500;
   }
 }
-async function routes18(fastify2) {
+async function routes19(fastify2) {
   const remoteRunMap = /* @__PURE__ */ new Map();
   const TERMINAL_RUN_STATUSES = /* @__PURE__ */ new Set(["completed", "cancelled", "failed"]);
   const trackRemoteRun = (localRun, info) => {
@@ -236599,6 +237713,12 @@ async function routes18(fastify2) {
       if (!clientProvidedBrief && !bareReviewerSessionId) {
         intentBrief2 = await distillIntentBrief(userId, sourceSessionId);
       }
+      if (reviewerSessionId && !await fastify2.remoteNotificationSync.prepareForNewTurn(reviewerSessionId)) {
+        return reply.code(502).send({
+          error: "Could not reach the remote server to prepare notification delivery",
+          errorCode: "notification_baseline_failed"
+        });
+      }
       const result = await proxyAuto(remoteInfo, "POST", "/api/path/workflow-runs", {
         sourceSessionId: remoteInfo.remoteSessionId,
         reviewFocus,
@@ -236632,7 +237752,12 @@ async function routes18(fastify2) {
           projectId,
           remoteInfo.remoteServerId,
           bareRun.reviewer_session_id,
-          bareRun.branch
+          bareRun.branch,
+          "from_start"
+        );
+        await fastify2.remoteNotificationSync.extendWatch(localRun.reviewer_session_id);
+        fastify2.remoteNotificationSync.enqueue(
+          () => fastify2.remoteNotificationSync.syncServer(remoteInfo.remoteServerId, { includeExpired: true })
         );
         ensureRemoteAgentStream(localRun.reviewer_session_id, {
           remoteSessionMap: fastify2.remoteSessionMap,
@@ -236641,6 +237766,11 @@ async function routes18(fastify2) {
           eventBus: fastify2.eventBus,
           agentSessionManager: fastify2.agentSessionManager
         });
+        fastify2.agentSessionManager.emitBranchActivityIfChanged(projectId, bareRun.branch, {
+          activity: "working",
+          since: Date.now(),
+          sessionId: localRun.reviewer_session_id
+        });
         fastify2.eventBus.emit({
           type: "session:process",
           projectId,
@@ -236755,7 +237885,8 @@ async function routes18(fastify2) {
           projectId,
           remoteInfo.remoteServerId,
           bareCandidate.sessionId,
-          remoteInfo.branch ?? null
+          remoteInfo.branch ?? null,
+          "from_now"
         );
       }
       return reply.send({ candidate: candidate2 });
@@ -236949,10 +238080,10 @@ async function routes18(fastify2) {
     return reply.send({ runs });
   });
 }
-var workflow_run_routes_default = (0, import_fastify_plugin19.default)(routes18, { name: "workflow-run-routes" });
+var workflow_run_routes_default = (0, import_fastify_plugin20.default)(routes19, { name: "workflow-run-routes" });
 
 // src/routes/settings-routes.ts
-var import_fastify_plugin20 = __toESM(require_plugin2(), 1);
+var import_fastify_plugin21 = __toESM(require_plugin2(), 1);
 var SettingsValidationError = class extends Error {
 };
 var DEFAULT_PROXY_CONFIG = { type: "none", host: "", port: 0 };
@@ -237016,7 +238147,7 @@ function requireSettingsUser(req, reply) {
   if (auth === null) return null;
   return resolveUserId(auth);
 }
-var routes19 = async (fastify2) => {
+var routes20 = async (fastify2) => {
   fastify2.get("/api/settings/agent-processes", async (req, reply) => {
     if (requireAuth(req, reply) === null) return;
     const saved = await fastify2.storage.settings.get("agentProcesses");
@@ -237290,11 +238421,11 @@ var routes19 = async (fastify2) => {
     return reply.code(200).send(updated);
   });
 };
-var settings_routes_default = (0, import_fastify_plugin20.default)(routes19, { name: "settings-routes" });
+var settings_routes_default = (0, import_fastify_plugin21.default)(routes20, { name: "settings-routes" });
 
 // src/routes/translate-routes.ts
-var import_fastify_plugin21 = __toESM(require_plugin2(), 1);
-var routes20 = async (fastify2) => {
+var import_fastify_plugin22 = __toESM(require_plugin2(), 1);
+var routes21 = async (fastify2) => {
   fastify2.post(
     "/api/translate",
     async (req, reply) => {
@@ -237335,10 +238466,10 @@ ${text2}`,
     }
   );
 };
-var translate_routes_default = (0, import_fastify_plugin21.default)(routes20, { name: "translate-routes" });
+var translate_routes_default = (0, import_fastify_plugin22.default)(routes21, { name: "translate-routes" });
 
 // src/routes/websocket-routes.ts
-var import_fastify_plugin22 = __toESM(require_plugin2(), 1);
+var import_fastify_plugin23 = __toESM(require_plugin2(), 1);
 
 // src/routes/executor-stream-handlers.ts
 import { randomUUID as randomUUID19 } from "crypto";
@@ -237616,7 +238747,7 @@ async function userOwnsSession(fastify2, sessionId, userId) {
 }
 
 // src/routes/websocket-routes.ts
-var routes21 = async (fastify2) => {
+var routes22 = async (fastify2) => {
   fastify2.reverseConnectManager.setStatusChangeHandler((remoteServerId, status) => {
     if (status !== "online") return;
     const cache2 = fastify2.remotePatchCache;
@@ -238003,13 +239134,13 @@ var routes21 = async (fastify2) => {
     );
   });
 };
-var websocket_routes_default = (0, import_fastify_plugin22.default)(routes21, { name: "websocket-routes" });
+var websocket_routes_default = (0, import_fastify_plugin23.default)(routes22, { name: "websocket-routes" });
 
 // src/routes/reverse-connect-routes.ts
-var import_fastify_plugin23 = __toESM(require_plugin2(), 1);
+var import_fastify_plugin24 = __toESM(require_plugin2(), 1);
 import { randomBytes as randomBytes2, createHash as createHash3, verify as cryptoVerify } from "crypto";
 var MACHINE_HANDSHAKE_TIMEOUT_MS = 5e3;
-var routes22 = async (fastify2) => {
+var routes23 = async (fastify2) => {
   fastify2.get("/api/reverse-connect/identity", async (req, reply) => {
     const token = req.headers["x-vibedeckx-connect-token"];
     if (typeof token !== "string" || token.length === 0) {
@@ -238119,10 +239250,10 @@ var routes22 = async (fastify2) => {
     );
   });
 };
-var reverse_connect_routes_default = (0, import_fastify_plugin23.default)(routes22, { name: "reverse-connect-routes" });
+var reverse_connect_routes_default = (0, import_fastify_plugin24.default)(routes23, { name: "reverse-connect-routes" });
 
 // src/routes/event-routes.ts
-var import_fastify_plugin24 = __toESM(require_plugin2(), 1);
+var import_fastify_plugin25 = __toESM(require_plugin2(), 1);
 function toWireEvent(event) {
   if (event.type === "executor:stopped" && (event.tailOutput !== void 0 || event.finalResult !== void 0)) {
     const { tailOutput: _tailOutput, finalResult: _finalResult, ...rest } = event;
@@ -238130,7 +239261,7 @@ function toWireEvent(event) {
   }
   return event;
 }
-var routes23 = async (fastify2) => {
+var routes24 = async (fastify2) => {
   fastify2.get("/api/events", async (req, reply) => {
     let userId = null;
     if (fastify2.authEnabled) {
@@ -238188,10 +239319,10 @@ var routes23 = async (fastify2) => {
     await reply;
   });
 };
-var event_routes_default = (0, import_fastify_plugin24.default)(routes23, { name: "event-routes" });
+var event_routes_default = (0, import_fastify_plugin25.default)(routes24, { name: "event-routes" });
 
 // src/routes/terminal-routes.ts
-var import_fastify_plugin25 = __toESM(require_plugin2(), 1);
+var import_fastify_plugin26 = __toESM(require_plugin2(), 1);
 import path13 from "path";
 async function getRemoteConfig5(fastify2, project, remoteServerId) {
   const remotes = await fastify2.storage.projectRemotes.getByProject(project.id);
@@ -238216,7 +239347,7 @@ async function getRemoteConfig5(fastify2, project, remoteServerId) {
   }
   return null;
 }
-var routes24 = async (fastify2) => {
+var routes25 = async (fastify2) => {
   fastify2.post("/api/path/terminals", async (req, reply) => {
     const { path: projectPath, branch } = req.body;
     if (!projectPath) {
@@ -238399,11 +239530,11 @@ var routes24 = async (fastify2) => {
     }
   );
 };
-var terminal_routes_default = (0, import_fastify_plugin25.default)(routes24, { name: "terminal-routes" });
+var terminal_routes_default = (0, import_fastify_plugin26.default)(routes25, { name: "terminal-routes" });
 
 // src/routes/browser-routes.ts
-var import_fastify_plugin26 = __toESM(require_plugin2(), 1);
-var routes25 = async (fastify2) => {
+var import_fastify_plugin27 = __toESM(require_plugin2(), 1);
+var routes26 = async (fastify2) => {
   const ensureProjectAccess = async (req, reply) => {
     const userId = requireAuth(req, reply);
     if (userId === null) return null;
@@ -238474,10 +239605,10 @@ var routes25 = async (fastify2) => {
     return reply.code(200).send({ ok: true });
   });
 };
-var browser_routes_default = (0, import_fastify_plugin26.default)(routes25, { name: "browser-routes" });
+var browser_routes_default = (0, import_fastify_plugin27.default)(routes26, { name: "browser-routes" });
 
 // src/routes/browser-proxy-routes.ts
-var import_fastify_plugin27 = __toESM(require_plugin2(), 1);
+var import_fastify_plugin28 = __toESM(require_plugin2(), 1);
 import { randomUUID as randomUUID20 } from "crypto";
 
 // src/utils/ssrf-guard.ts
@@ -238973,7 +240104,7 @@ function generateInjectedScript(projectId, targetOrigin, proxyWsPrefix) {
 })();
 </script>`;
 }
-var routes26 = async (fastify2) => {
+var routes27 = async (fastify2) => {
   fastify2.get("/api/projects/:id/browser/proxy/*", async (req, reply) => {
     const userId = requireAuth(req, reply);
     if (userId === null) return;
@@ -239144,10 +240275,10 @@ var routes26 = async (fastify2) => {
     });
   });
 };
-var browser_proxy_routes_default = (0, import_fastify_plugin27.default)(routes26, { name: "browser-proxy-routes" });
+var browser_proxy_routes_default = (0, import_fastify_plugin28.default)(routes27, { name: "browser-proxy-routes" });
 
 // src/routes/cross-remote-target-routes.ts
-var import_fastify_plugin28 = __toESM(require_plugin2(), 1);
+var import_fastify_plugin29 = __toESM(require_plugin2(), 1);
 import path14 from "path";
 import { promises as fs3 } from "fs";
 
@@ -239227,7 +240358,7 @@ var clampTimeoutMs = (timeoutSec) => {
   const requested = typeof timeoutSec === "number" && Number.isFinite(timeoutSec) && timeoutSec > 0 ? timeoutSec : DEFAULT_TIMEOUT_SEC;
   return Math.min(requested, MAX_TIMEOUT_SEC) * 1e3;
 };
-var routes27 = async (fastify2) => {
+var routes28 = async (fastify2) => {
   fastify2.post(
     "/api/path/cross-remote/exec",
     async (request, reply) => {
@@ -239335,10 +240466,10 @@ var routes27 = async (fastify2) => {
     return reply.send(result);
   });
 };
-var cross_remote_target_routes_default = (0, import_fastify_plugin28.default)(routes27, { name: "cross-remote-target-routes" });
+var cross_remote_target_routes_default = (0, import_fastify_plugin29.default)(routes28, { name: "cross-remote-target-routes" });
 
 // src/routes/cross-remote-mcp-routes.ts
-var import_fastify_plugin29 = __toESM(require_plugin2(), 1);
+var import_fastify_plugin30 = __toESM(require_plugin2(), 1);
 var PROTOCOL_VERSION = "2024-11-05";
 var AUDIT_ARGS_MAX = 1024;
 var NOT_ACCESSIBLE = "remote not found or not accessible";
@@ -239441,7 +240572,7 @@ var textResult = (text2, isError = false) => ({
   content: [{ type: "text", text: text2 }],
   ...isError ? { isError: true } : {}
 });
-var routes28 = async (fastify2) => {
+var routes29 = async (fastify2) => {
   const guard = new SessionConcurrencyGuard();
   let cachedSecret;
   const getSecret = () => {
@@ -239564,10 +240695,10 @@ var routes28 = async (fastify2) => {
     }
   });
 };
-var cross_remote_mcp_routes_default = (0, import_fastify_plugin29.default)(routes28, { name: "cross-remote-mcp-routes" });
+var cross_remote_mcp_routes_default = (0, import_fastify_plugin30.default)(routes29, { name: "cross-remote-mcp-routes" });
 
 // src/routes/schedule-routes.ts
-var import_fastify_plugin30 = __toESM(require_plugin2(), 1);
+var import_fastify_plugin31 = __toESM(require_plugin2(), 1);
 import { randomUUID as randomUUID21 } from "crypto";
 import path15 from "path";
 var RUN_TYPES = ["command", "prompt"];
@@ -239583,7 +240714,7 @@ function validateResolved(b2) {
   if (cronError) return `Invalid cron expression: ${cronError}`;
   return null;
 }
-var routes29 = async (fastify2) => {
+var routes30 = async (fastify2) => {
   const getAuthorizedSchedule = async (id, userId, reply) => {
     const schedule = await fastify2.storage.scheduledTasks.getById(id);
     if (!schedule) {
@@ -239755,7 +240886,7 @@ var routes29 = async (fastify2) => {
     }
   );
 };
-var schedule_routes_default = (0, import_fastify_plugin30.default)(routes29, { name: "schedule-routes" });
+var schedule_routes_default = (0, import_fastify_plugin31.default)(routes30, { name: "schedule-routes" });
 
 // src/search/catalog.ts
 var parseDbTimestamp3 = (ts) => {
@@ -239959,7 +241090,8 @@ var searchRoutes = async (fastify2) => {
           target.projectId,
           target.targetId,
           s3.id,
-          mapBranch
+          mapBranch,
+          "from_now"
         );
         return { ...s3, id: localSessionId };
       }));
@@ -239996,6 +241128,44 @@ var searchRoutes = async (fastify2) => {
 };
 var search_routes_default = searchRoutes;
 
+// src/routes/notification-routes.ts
+var import_fastify_plugin32 = __toESM(require_plugin2(), 1);
+var MAX_LIMIT = 500;
+var DEFAULT_LIMIT = 100;
+var routes31 = async (fastify2) => {
+  fastify2.get(
+    "/api/notifications",
+    async (req, reply) => {
+      const authResult = requireAuth(req, reply);
+      if (authResult === null) return;
+      const userId = resolveUserId(authResult);
+      const requested = Number(req.query.limit);
+      const limit = Number.isFinite(requested) && requested > 0 ? Math.min(Math.floor(requested), MAX_LIMIT) : DEFAULT_LIMIT;
+      const notifications = await fastify2.storage.notifications.listForUser(userId, {
+        limit,
+        unreadOnly: req.query.unread === "true"
+      });
+      return reply.code(200).send({ notifications });
+    }
+  );
+  fastify2.patch("/api/notifications/:id/read", async (req, reply) => {
+    const authResult = requireAuth(req, reply);
+    if (authResult === null) return;
+    const userId = resolveUserId(authResult);
+    const ok = await fastify2.storage.notifications.markRead(req.params.id, userId);
+    if (!ok) return reply.code(404).send({ error: "Not found" });
+    return reply.code(200).send({ ok: true });
+  });
+  fastify2.post("/api/notifications/read-all", async (req, reply) => {
+    const authResult = requireAuth(req, reply);
+    if (authResult === null) return;
+    const userId = resolveUserId(authResult);
+    await fastify2.storage.notifications.markAllRead(userId);
+    return reply.code(200).send({ ok: true });
+  });
+};
+var notification_routes_default = (0, import_fastify_plugin32.default)(routes31, { name: "notification-routes" });
+
 // ../../node_modules/.pnpm/@clerk+fastify@3.1.2_fastify@5.7.2_react-dom@19.2.3_react@19.2.3__react@19.2.3/node_modules/@clerk/fastify/dist/chunk-RY4T2JMQ.mjs
 import { Readable as Readable3 } from "stream";
 var fastifyRequestToRequest = (req) => {
@@ -240046,7 +241216,7 @@ var requestToProxyRequest = (req) => {
 
 // ../../node_modules/.pnpm/@clerk+fastify@3.1.2_fastify@5.7.2_react-dom@19.2.3_react@19.2.3__react@19.2.3/node_modules/@clerk/fastify/dist/index.mjs
 init_dist();
-var import_fastify_plugin31 = __toESM(require_plugin2(), 1);
+var import_fastify_plugin33 = __toESM(require_plugin2(), 1);
 
 // ../../node_modules/.pnpm/@clerk+backend@3.2.0_react-dom@19.2.3_react@19.2.3__react@19.2.3/node_modules/@clerk/backend/dist/internal.mjs
 init_chunk_JW73PKED();
@@ -240334,7 +241504,7 @@ var plugin = (instance, opts, done) => {
   instance.addHook(hookName, withClerkMiddleware(opts));
   done();
 };
-var clerkPlugin = (0, import_fastify_plugin31.default)(plugin, {
+var clerkPlugin = (0, import_fastify_plugin33.default)(plugin, {
   name: "@clerk/fastify",
   fastify: "5.x"
 });
@@ -241223,6 +242393,7 @@ var createServer = async (opts) => {
     authEnabled,
     clerkPublishableKey: authEnabled ? process.env.CLERK_PUBLISHABLE_KEY : void 0,
     localProjectsEnabled: !noLocalProjects,
+    discordInviteUrl: process.env.VIBEDECKX_DISCORD_URL || void 0,
     // Capability flag for the reverse-connect identity preflight. Workers
     // check this before calling /api/reverse-connect/identity so an auth
     // middleware 401 from an older hub (which lacks the endpoint AND its
@@ -241282,6 +242453,8 @@ var createServer = async (opts) => {
   server.register(settings_routes_default);
   server.register(translate_routes_default);
   server.register(event_routes_default);
+  server.register(notification_routes_default);
+  server.register(notification_outbox_routes_default);
   server.register(terminal_routes_default);
   server.register(browser_routes_default);
   server.register(browser_proxy_routes_default);
@@ -243623,7 +244796,7 @@ var connectRoutes = buildRouteMap({
   defaultCommand: "run",
   docs: { brief: "Connect to a Vibedeckx server as an inbound node" }
 });
-var routes30 = buildRouteMap({
+var routes32 = buildRouteMap({
   routes: {
     start: startCommand,
     connect: connectRoutes
@@ -243633,7 +244806,7 @@ var routes30 = buildRouteMap({
     brief: "Vibedeckx - AI-powered app generator"
   }
 });
-var program = buildApplication(routes30, {
+var program = buildApplication(routes32, {
   name: "vibedeckx",
   versionInfo: {
     currentVersion: readPackageVersion()