@vibedeckx/darwin-arm64 0.2.15 → 0.2.17

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,
@@ -185596,6 +185613,7 @@ var mapAgentSession = (row) => ({
   permission_mode: row.permission_mode ?? void 0,
   agent_type: row.agent_type ?? void 0,
   title: row.title,
+  model: row.model ?? null,
   created_at: row.created_at,
   updated_at: row.updated_at,
   last_user_message_at: row.last_user_message_at,
@@ -185610,7 +185628,7 @@ var createAgentSessionRepos = (kdb, h) => ({
     // writes — this is what lets getLatestByBranch break ties
     // deterministically (see the schema.ts / sqlite.ts DDL comment on
     // agent_sessions).
-    create: async ({ id, project_id, branch, permission_mode, agent_type }) => {
+    create: async ({ id, project_id, branch, permission_mode, agent_type, model }) => {
       await kdb.insertInto("agent_sessions").values({
         id,
         project_id,
@@ -185618,6 +185636,7 @@ var createAgentSessionRepos = (kdb, h) => ({
         status: "running",
         permission_mode: permission_mode ?? "edit",
         agent_type: agent_type ?? "claude-code",
+        model: model ?? null,
         created_at: h.nowMs(),
         updated_at: h.nowMs()
       }).execute();
@@ -185660,6 +185679,9 @@ var createAgentSessionRepos = (kdb, h) => ({
     updateAgentType: async (id, agent_type) => {
       await kdb.updateTable("agent_sessions").set({ agent_type, updated_at: h.nowMs() }).where("id", "=", id).execute();
     },
+    updateModel: async (id, model) => {
+      await kdb.updateTable("agent_sessions").set({ model, updated_at: h.nowMs() }).where("id", "=", id).execute();
+    },
     updateTitle: async (id, title) => {
       await kdb.updateTable("agent_sessions").set({ title, updated_at: h.nowMs() }).where("id", "=", id).execute();
     },
@@ -185690,6 +185712,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 +185736,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 +185759,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 +186321,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 +186362,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);
@@ -186360,6 +186596,10 @@ var createDatabase = (dbPath) => {
       branch TEXT NOT NULL DEFAULT '',
       status TEXT NOT NULL DEFAULT 'running',
       title TEXT DEFAULT NULL,
+      -- Per-session agent model, e.g. 'opus' or 'gpt-5.6-sol'. NULL = use the
+      -- CLI's own default (no flag is passed). Never validated: an unknown
+      -- name is passed to the CLI and fails there.
+      model TEXT DEFAULT NULL,
       -- Millisecond-precision timestamps. CURRENT_TIMESTAMP is seconds-only,
       -- which lets two sessions tie on updated_at within the same second and
       -- corrupts the ordering used by getLatestByBranch. The 'YYYY-MM-DD
@@ -186632,6 +186872,10 @@ var createDatabase = (dbPath) => {
   if (!sessionInfoV6.some((col) => col.name === "favorited_at")) {
     db.exec("ALTER TABLE agent_sessions ADD COLUMN favorited_at INTEGER DEFAULT NULL");
   }
+  const sessionInfoV7 = db.prepare("PRAGMA table_info(agent_sessions)").all();
+  if (!sessionInfoV7.some((col) => col.name === "model")) {
+    db.exec("ALTER TABLE agent_sessions ADD COLUMN model TEXT DEFAULT NULL");
+  }
   db.exec(`
     CREATE INDEX IF NOT EXISTS idx_agent_sessions_project_branch
       ON agent_sessions(project_id, branch);
@@ -186975,7 +187219,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 +187325,7 @@ var createSqliteStorage = async (dbPath) => {
     ...createSearchCacheRepos(kdb, h),
     ...createWorkflowRunRepos(kdb),
     ...createTurnSnapshotRepos(kdb),
+    ...createNotificationRepos(kdb),
     close: async () => {
       await kdb.destroy();
     }
@@ -187038,7 +187342,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";
@@ -201019,8 +201323,11 @@ var UserInputParamsSchema = external_exports.looseObject({
 
 // src/protocol/codex/cli.ts
 var CROSS_REMOTE_MCP_TOKEN_ENV = "VIBEDECKX_CROSS_REMOTE_MCP_TOKEN";
-function buildCodexAppServerSpawnConfig(nativeBinary, crossRemoteMcp) {
+function buildCodexAppServerSpawnConfig(nativeBinary, crossRemoteMcp, model) {
   const args = ["app-server"];
+  if (model && model.trim()) {
+    args.push("-c", `model=${JSON.stringify(model.trim())}`);
+  }
   if (crossRemoteMcp) {
     args.push(
       "-c",
@@ -201105,11 +201412,16 @@ function withNpxFallback(nativeBinary, args) {
   }
   return { command: "npx", args: ["-y", CLAUDE_NPM_PACKAGE, ...args] };
 }
-function buildClaudeSessionSpawnConfig(nativeBinary, permissionMode, mcpConfigArg) {
+function buildClaudeSessionSpawnConfig(nativeBinary, permissionMode, mcpConfigArg, model) {
   const permissionFlag = permissionMode === "plan" ? "--permission-mode=plan" : "--dangerously-skip-permissions";
   const args = [
     ...STREAM_JSON_ARGS,
-    permissionFlag,
+    permissionFlag
+  ];
+  if (model && model.trim()) {
+    args.push("--model", model.trim());
+  }
+  args.push(
     // AskUserQuestion can't work over piped (non-TTY) stdin: claude resolves it
     // internally as "dismissed" before we can present a picker and wait for the
     // user. Disable it so the agent falls back to asking in plain text, which the
@@ -201117,7 +201429,7 @@ function buildClaudeSessionSpawnConfig(nativeBinary, permissionMode, mcpConfigAr
     "--disallowedTools",
     "AskUserQuestion",
     "--verbose"
-  ];
+  );
   if (mcpConfigArg) {
     args.push("--mcp-config", mcpConfigArg);
   }
@@ -202016,6 +202328,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";
@@ -202159,11 +202522,12 @@ var ClaudeCodeProvider = class {
   isAvailable() {
     return true;
   }
-  buildSpawnConfig(_cwd, permissionMode, crossRemoteMcp) {
+  buildSpawnConfig(_cwd, permissionMode, crossRemoteMcp, model) {
     return buildClaudeSessionSpawnConfig(
       this.detectBinary(),
       permissionMode,
-      crossRemoteMcp ? buildMcpConfigArg(crossRemoteMcp) : void 0
+      crossRemoteMcp ? buildMcpConfigArg(crossRemoteMcp) : void 0,
+      model
     );
   }
   parseStdoutLine(line, _sessionId) {
@@ -202353,9 +202717,9 @@ var CodexProvider = class _CodexProvider {
   isAvailable() {
     return true;
   }
-  buildSpawnConfig(_cwd, permissionMode, crossRemoteMcp) {
+  buildSpawnConfig(_cwd, permissionMode, crossRemoteMcp, model) {
     this.lastPermissionMode = permissionMode;
-    return buildCodexAppServerSpawnConfig(this.detectBinary(), crossRemoteMcp);
+    return buildCodexAppServerSpawnConfig(this.detectBinary(), crossRemoteMcp, model);
   }
   // ============ Task 5.5: parseStdoutLine — JSON-RPC message routing ============
   parseStdoutLine(line, sessionId) {
@@ -224253,6 +224617,21 @@ var TurnCompletionLedger = class {
 };
 
 // src/agent-session-manager.ts
+function buildStartupFailureMessage(agentType, stderrTail, stdoutTail) {
+  const provider = getProvider(agentType);
+  const name25 = provider.getDisplayName();
+  const details = [stdoutTail.trim(), stderrTail.trim()].filter(Boolean).join("\n");
+  const hint = stdoutTail.trim() ? void 0 : provider.getInstallHint?.();
+  let msg = `Couldn't start ${name25}.`;
+  if (hint) msg += `
+
+${hint}`;
+  if (details) msg += `
+
+Details:
+${details}`;
+  return msg;
+}
 var SUMMARY_TEXT_CAP = 1500;
 function extractLastAssistantText(entries) {
   for (let i = entries.length - 1; i >= 0; i--) {
@@ -224295,6 +224674,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
@@ -224529,6 +224938,7 @@ var AgentSessionManager = class {
     await this.ensureResidentCapacity({ projectId, branch }, { force });
     const sessionId = opts.sessionId ?? randomUUID();
     const branchKey = branch ?? "";
+    const model = opts.model?.trim() ? opts.model.trim() : null;
     const absoluteWorktreePath = resolveWorktreePath(projectPath, branch);
     if (!skipDb) {
       await this.storage.agentSessions.create({
@@ -224536,7 +224946,8 @@ var AgentSessionManager = class {
         project_id: projectId,
         branch: branchKey,
         permission_mode: permissionMode,
-        agent_type: agentType
+        agent_type: agentType,
+        model
       });
     }
     if (!skipDb) {
@@ -224564,13 +224975,15 @@ var AgentSessionManager = class {
       permissionMode,
       crossRemoteMcp: opts.crossRemoteMcp,
       agentType,
+      model,
       completion: new TurnCompletionLedger(),
       graceTimer: null,
       eventChain: Promise.resolve(),
       bgSpawnHintsThisTurn: 0,
       taskStartedThisTurn: 0,
       lastActiveAt: Date.now(),
-      turnOpenSince: null
+      turnOpenSince: null,
+      turnDisposition: null
     };
     this.sessions.set(sessionId, session);
     const provider = getProvider(agentType);
@@ -224653,7 +225066,7 @@ var AgentSessionManager = class {
       this.broadcastRaw(session.id, { finished: true });
       return;
     }
-    const config2 = provider.buildSpawnConfig(cwd, session.permissionMode, session.crossRemoteMcp);
+    const config2 = provider.buildSpawnConfig(cwd, session.permissionMode, session.crossRemoteMcp, session.model);
     if (config2.command !== "npx") {
       const agentVersion = getBinaryVersion(config2.command);
       console.log(`[AgentSession] ${provider.getDisplayName()} version: ${agentVersion ?? "unknown (--version probe failed)"}`);
@@ -224661,6 +225074,7 @@ var AgentSessionManager = class {
       console.log(`[AgentSession] ${provider.getDisplayName()} running via npx (version resolved at spawn by npm)`);
     }
     session.producedOutput = false;
+    session.unparsedStdoutTail = "";
     this.resetCompletion(session);
     let stderrTail = "";
     let spawnFailed = false;
@@ -224709,7 +225123,7 @@ var AgentSessionManager = class {
           try {
             await this.pushEntry(session.id, {
               type: "error",
-              message: this.buildStartupFailureMessage(session.agentType, stderrTail),
+              message: buildStartupFailureMessage(session.agentType, stderrTail, session.unparsedStdoutTail ?? ""),
               timestamp: Date.now()
             }, true);
           } catch (err) {
@@ -224742,7 +225156,7 @@ var AgentSessionManager = class {
       const isNotFound = error48.code === "ENOENT";
       this.pushEntry(session.id, {
         type: "error",
-        message: isNotFound ? this.buildStartupFailureMessage(session.agentType, stderrTail) : error48.message,
+        message: isNotFound ? buildStartupFailureMessage(session.agentType, stderrTail, session.unparsedStdoutTail ?? "") : error48.message,
         timestamp: Date.now()
       }, true).catch((err) => {
         console.error(`[AgentSession] Failed to push spawn-error entry for ${session.id}:`, err);
@@ -224867,6 +225281,8 @@ var AgentSessionManager = class {
       const events = provider.parseStdoutLine(line, session.id);
       if (events.length > 0) {
         session.producedOutput = true;
+      } else {
+        session.unparsedStdoutTail = ((session.unparsedStdoutTail ?? "") + line + "\n").slice(-4e3);
       }
       for (const event of events) {
         await this.processAgentEvent(session.id, event);
@@ -225121,32 +225537,21 @@ var AgentSessionManager = class {
    * Push a new entry with ADD patch
    */
   /**
-   * Build a user-facing message for when an agent process fails to start.
-   * Includes the provider's install hint plus any captured stderr tail.
+   * 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.
    */
-  buildStartupFailureMessage(agentType, stderrTail) {
-    const provider = getProvider(agentType);
-    const name25 = provider.getDisplayName();
-    const hint = provider.getInstallHint?.();
-    let msg = `Couldn't start ${name25}.`;
-    if (hint) msg += `
-
-${hint}`;
-    const details = stderrTail.trim();
-    if (details) msg += `
-
-Details:
-${details}`;
-    return msg;
+  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 +225560,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 +225652,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 +225688,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 +225714,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 +225724,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);
@@ -225554,12 +226027,19 @@ ${details}`;
     session.store.currentAssistantIndex = null;
     session.buffer = "";
     this.resetCompletion(session);
+    const previousAgentType = session.agentType;
     getProvider(session.agentType).onSessionDestroyed?.(sessionId);
     session.agentType = agentType;
     if (!session.skipDb) await this.storage.agentSessions.updateAgentType(sessionId, agentType);
+    const clearedModel = session.model;
+    if (clearedModel !== null) {
+      session.model = null;
+      if (!session.skipDb) await this.storage.agentSessions.updateModel(sessionId, null);
+    }
+    const agentDisplayName = (t) => t === "codex" ? "Codex" : "Claude Code";
     await this.pushEntry(sessionId, {
       type: "system",
-      content: `Coding agent switched to ${agentType === "codex" ? "Codex" : "Claude Code"}.`,
+      content: `Coding agent switched to ${agentDisplayName(agentType)}.` + (clearedModel !== null ? ` Model reset to the default (\`${clearedModel}\` was set for ${agentDisplayName(previousAgentType)}).` : ""),
       timestamp: Date.now()
     });
     session.dormant = true;
@@ -225691,7 +226171,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 +226192,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 +226263,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 +226279,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 +226334,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";
@@ -225842,13 +226351,15 @@ ${details}`;
         skipDb: false,
         permissionMode,
         agentType: dbSession.agent_type || "claude-code",
+        model: dbSession.model ?? null,
         completion: new TurnCompletionLedger(),
         graceTimer: null,
         eventChain: Promise.resolve(),
         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");
@@ -225902,13 +226413,16 @@ ${details}`;
     const branch = source?.branch ?? (sourceRow.branch || null);
     const permissionMode = source?.permissionMode ?? (sourceRow?.permission_mode === "plan" ? "plan" : "edit");
     const agentType = agentTypeOverride ?? source?.agentType ?? (sourceRow?.agent_type || "claude-code");
+    const sourceAgentType = source?.agentType ?? (sourceRow?.agent_type || "claude-code");
+    const model = agentType === sourceAgentType ? source?.model ?? sourceRow?.model ?? null : null;
     const newId = opts.sessionId ?? randomUUID();
     await this.storage.agentSessions.create({
       id: newId,
       project_id: projectId,
       branch: branch ?? "",
       permission_mode: permissionMode,
-      agent_type: agentType
+      agent_type: agentType,
+      model
     });
     await this.storage.agentSessions.updateStatusPreservingTimestamp(newId, "stopped");
     for (const row of entryRows) {
@@ -225943,6 +226457,7 @@ ${details}`;
       skipDb: false,
       permissionMode,
       agentType,
+      model,
       completion: new TurnCompletionLedger(),
       graceTimer: null,
       eventChain: Promise.resolve(),
@@ -225950,6 +226465,7 @@ ${details}`;
       taskStartedThisTurn: 0,
       lastActiveAt: Date.now(),
       turnOpenSince: null,
+      turnDisposition: null,
       crossRemoteMcp: opts.crossRemoteMcp
     };
     this.sessions.set(newId, branched);
@@ -226296,9 +226812,397 @@ 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;
+  const { projectId, agentMode, remoteConfig, branch, permissionMode, agentType, model, force, userId } = params;
   const remoteSessionId = randomUUID3();
   const localSessionId = `remote-${agentMode}-${projectId}-${remoteSessionId}`;
   const crossRemoteMcp = await mintCrossRemoteMcpConfig(
@@ -226320,7 +227224,7 @@ async function createRemoteAgentSession(deps, params) {
       remoteConfig.server_api_key || "",
       "POST",
       `/api/path/agent-sessions/new`,
-      { path: remoteConfig.remote_path, branch, permissionMode, agentType, force, sessionId: remoteSessionId, crossRemoteMcp },
+      { path: remoteConfig.remote_path, branch, permissionMode, agentType, force, sessionId: remoteSessionId, crossRemoteMcp, model },
       { reverseConnectManager: deps.reverseConnectManager ?? void 0 }
     );
     if (!result.ok) {
@@ -226332,7 +227236,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 +229880,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 +230084,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 +230260,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 +230305,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 +230316,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 +230341,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 +230379,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 +230400,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 +232214,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 +232500,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 +232528,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 +232547,8 @@ var sharedServices = async (fastify2, opts) => {
   });
   fastify2.addHook("onClose", async () => {
     scheduler.shutdown();
+    notificationService.shutdown();
+    remoteNotificationSync.shutdown();
     agentSessionManager.shutdown();
     processManager.shutdown();
     remotePatchCache.shutdown();
@@ -231416,10 +232557,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 +232613,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 +232875,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 +232932,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 +233127,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 +233229,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 +233305,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 +233454,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 +233670,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 +233699,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 +234237,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 +234560,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 +234755,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 +234994,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 +235588,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";
@@ -234482,6 +235623,14 @@ function resolveUserId(authResult) {
 
 // src/routes/agent-session-routes.ts
 import { randomUUID as randomUUID15 } from "crypto";
+
+// src/protocol/model-suggestions.ts
+var MODEL_SUGGESTIONS = {
+  "claude-code": ["opus", "sonnet", "haiku"],
+  codex: ["gpt-5.6-sol", "gpt-5.6-codex", "o3"]
+};
+
+// src/routes/agent-session-routes.ts
 async function resolveProjectPath(projectId, storage) {
   if (projectId.startsWith("path:")) {
     return projectId.slice(5);
@@ -234498,7 +235647,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
@@ -234545,6 +235694,7 @@ var routes11 = async (fastify2) => {
           status: session?.status || "stopped",
           permissionMode: session?.permissionMode || "edit",
           agentType: session?.agentType || "claude-code",
+          model: session?.model ?? null,
           title: dbRow?.title ?? null
         },
         messages
@@ -234555,15 +235705,23 @@ var routes11 = async (fastify2) => {
     fastify2.agentSessionManager.emitSessionTitle(projectId, branch, sessionId, title);
   }
   fastify2.get("/api/agent-providers", async (_req, reply) => {
-    const providers2 = getAllProviders().map((provider) => ({
-      type: provider.getAgentType(),
-      displayName: provider.getDisplayName(),
-      available: provider.isAvailable?.() ?? provider.detectBinary() !== null
-    }));
+    const providers2 = getAllProviders().map((provider) => {
+      const type = provider.getAgentType();
+      return {
+        type,
+        displayName: provider.getDisplayName(),
+        available: provider.isAvailable?.() ?? provider.detectBinary() !== null,
+        // Suggestions only. The picker also accepts free text, and nothing
+        // validates against this list — the session's real capabilities depend
+        // on the CLI version and account tier of whichever machine spawns it,
+        // which this server cannot know.
+        models: MODEL_SUGGESTIONS[type] ?? []
+      };
+    });
     return reply.code(200).send({ providers: providers2 });
   });
   fastify2.post("/api/path/agent-sessions", async (req, reply) => {
-    const { path: projectPath, branch, permissionMode, agentType, force } = req.body;
+    const { path: projectPath, branch, permissionMode, agentType, force, model } = req.body;
     if (!projectPath) {
       return reply.code(400).send({ error: "Path is required" });
     }
@@ -234611,6 +235769,7 @@ var routes11 = async (fastify2) => {
           status: effectiveStatus,
           permissionMode: session?.permissionMode || "edit",
           agentType: session?.agentType || "claude-code",
+          model: session?.model ?? null,
           processAlive: session ? fastify2.agentSessionManager.getSessionProcessAlive(sessionId) : false
         },
         messages
@@ -234655,7 +235814,7 @@ var routes11 = async (fastify2) => {
     }
   );
   fastify2.post("/api/path/agent-sessions/new", async (req, reply) => {
-    const { path: projectPath, branch, permissionMode, agentType, force, sessionId, crossRemoteMcp } = req.body;
+    const { path: projectPath, branch, permissionMode, agentType, force, sessionId, crossRemoteMcp, model } = req.body;
     if (!projectPath) {
       return reply.code(400).send({ error: "Path is required" });
     }
@@ -234683,7 +235842,7 @@ var routes11 = async (fastify2) => {
         agentType || "claude-code",
         false,
         force === true,
-        { sessionId, crossRemoteMcp }
+        { sessionId, crossRemoteMcp, model }
       );
       const session = fastify2.agentSessionManager.getSession(createdSessionId);
       return reply.code(200).send({
@@ -234694,6 +235853,7 @@ var routes11 = async (fastify2) => {
           status: session?.status || "running",
           permissionMode: session?.permissionMode || "edit",
           agentType: session?.agentType || "claude-code",
+          model: session?.model ?? null,
           processAlive: session ? fastify2.agentSessionManager.getSessionProcessAlive(session.id) : false
         },
         messages: []
@@ -234756,7 +235916,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 };
         }));
@@ -234795,7 +235956,7 @@ var routes11 = async (fastify2) => {
     if (!project) {
       return reply.code(404).send({ error: "Project not found" });
     }
-    const { branch, permissionMode, agentType } = req.body;
+    const { branch, permissionMode, agentType, model } = req.body;
     let agentMode = project.agent_mode;
     let useRemoteAgent = agentMode !== "local";
     if (useRemoteAgent && agentMode === "remote") {
@@ -234830,7 +235991,7 @@ var routes11 = async (fastify2) => {
           remoteConfig.server_api_key || "",
           "POST",
           `/api/path/agent-sessions`,
-          { path: remoteConfig.remote_path, branch, permissionMode, agentType }
+          { path: remoteConfig.remote_path, branch, permissionMode, agentType, model }
         );
         console.log(`[API] Remote proxy result: ok=${result.ok}, status=${result.status}, data=${JSON.stringify(result.data).substring(0, 500)}`);
         if (result.ok) {
@@ -234851,7 +236012,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);
@@ -234907,6 +236069,7 @@ var routes11 = async (fastify2) => {
           status: effectiveStatus,
           permissionMode: session?.permissionMode || "edit",
           agentType: session?.agentType || "claude-code",
+          model: session?.model ?? null,
           processAlive: session ? fastify2.agentSessionManager.getSessionProcessAlive(sessionId) : false
         },
         messages
@@ -234923,7 +236086,7 @@ var routes11 = async (fastify2) => {
     if (!project) {
       return reply.code(404).send({ error: "Project not found" });
     }
-    const { branch, permissionMode, agentType, force } = req.body;
+    const { branch, permissionMode, agentType, force, model } = req.body;
     const agentMode = project.agent_mode;
     const useRemoteAgent = agentMode !== "local";
     if (useRemoteAgent) {
@@ -234949,7 +236112,8 @@ var routes11 = async (fastify2) => {
             permissionMode: permissionMode || "edit",
             agentType,
             force: force === true,
-            userId
+            userId,
+            model
           }
         );
         if (created.ok) {
@@ -234982,7 +236146,7 @@ var routes11 = async (fastify2) => {
         agentType || "claude-code",
         false,
         force === true,
-        { sessionId: preSessionId, crossRemoteMcp }
+        { sessionId: preSessionId, crossRemoteMcp, model }
       );
       const session = fastify2.agentSessionManager.getSession(sessionId);
       return reply.code(200).send({
@@ -234993,6 +236157,7 @@ var routes11 = async (fastify2) => {
           status: session?.status || "running",
           permissionMode: session?.permissionMode || "edit",
           agentType: session?.agentType || "claude-code",
+          model: session?.model ?? null,
           processAlive: session ? fastify2.agentSessionManager.getSessionProcessAlive(sessionId) : false
         },
         messages: []
@@ -235049,6 +236214,7 @@ var routes11 = async (fastify2) => {
           status: session.status,
           permissionMode: session.permissionMode,
           agentType: session.agentType || "claude-code",
+          model: session.model ?? null,
           processAlive: fastify2.agentSessionManager.getSessionProcessAlive(session.id)
         },
         messages
@@ -235078,6 +236244,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 +236504,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 +236800,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 +236818,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 +236885,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 +237022,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 +237146,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 +237255,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 +237406,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 +237497,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,83 +237571,274 @@ 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;
-var PER_MESSAGE_MAX_CHARS = 1500;
-var TOTAL_INPUT_MAX_CHARS = 24e3;
-var HEAD_CHARS = 8e3;
-var TAIL_CHARS = 15e3;
+var BASE_TIMEOUT_MS = 15e3;
+var TIMEOUT_MS_PER_1K_CHARS = 120;
+var MAX_TIMEOUT_MS = 6e4;
+var PER_MESSAGE_MAX_CHARS = 6e3;
+var COMPACT_TRIGGER_CHARS = 12e4;
+var COMPACT_SLICE_BUDGETS = [96e3, 24e3, 6e3];
+var RECENT_VERBATIM_RATIO = 0.3;
+var MIN_RECENT_VERBATIM_CHARS = 2e3;
+var MAX_FOLD_CALLS = 8;
+var COMPACT_SUMMARY_MAX_CHARS = 6e3;
+var COMPACT_SUMMARY_MAX_TOKENS = 1500;
+var REVERSALS_MAX_CHARS = 2e3;
+var REVERSALS_MAX_TOKENS = 500;
 var BRIEF_MAX_CHARS = 4e3;
+var BRIEF_MAX_TOKENS = 1e3;
+var REVERSAL_MIN_CHARS = 6e3;
+var SEP = "\n\n";
+var COMPACTION_NOTE = "_Note: the source conversation was compressed before distillation \u2014 older turns were summarized rather than read verbatim._";
+var BRIEF_TRUNCATION_NOTE = "\n\n_[brief truncated at the length limit \u2014 treat it as incomplete]_";
 var SYSTEM_PROMPT2 = [
   "You distill a coding-agent conversation into an intent brief for an independent code reviewer.",
   "The reviewer will NOT see the conversation \u2014 only your brief plus the actual code, so capture what the code alone cannot show:",
   "1. The original request and its goal.",
-  "2. Constraints and explicit user decisions, including approaches the user rejected.",
+  "2. Constraints and decisions, including approaches that were rejected and why. A rejection counts whether the user made it or the agent made it under a principle the user set.",
   "3. Trade-offs or limitations that were acknowledged and accepted.",
-  "Do NOT include the agent's reasoning, self-assessment, or claims that the work is correct or complete \u2014 the reviewer must judge that independently.",
-  "Write concise markdown bullets under those numbered headings, under 400 words total, in the same language as the conversation. Reply with the brief only."
+  "4. Behaviour established by actually running something \u2014 observed output, exit codes, error text, which stream an error arrived on. Report what was observed; that is evidence the reviewer cannot recover by reading code.",
+  "Later statements supersede earlier ones on the same topic. An option explored at length early is often rejected later in a single sentence, and the rejection wins. Where the conversation ends in a decision table or summary, that is authoritative wherever it conflicts with earlier prose.",
+  "The input may arrive as numbered compressed slices followed by verbatim recent turns. Slice numbers are chronological: a later slice overrules an earlier one.",
+  "Decisions the agent made that the user did not contradict are binding \u2014 silence is agreement.",
+  "Do NOT include the agent's self-assessment or any claim that the work is correct or complete \u2014 the reviewer must judge that independently.",
+  "Every statement must trace to something in the conversation. If a heading has nothing real to report, say so rather than inventing plausible-sounding content.",
+  "Write concise markdown bullets under those numbered headings, under 500 words total, in the same language as the conversation. Reply with the brief only."
 ].join("\n");
-function capText(text2, max) {
-  return text2.length > max ? text2.slice(0, max) + "\u2026" : text2;
+var REVERSAL_SYSTEM_PROMPT = [
+  "You read a coding-agent conversation and report ONLY the conclusions that were later reversed, dropped, or replaced.",
+  "A design conversation converges by killing its own hypotheses: an option explored in depth early is often rejected later in one sentence, so weigh finality over how much was written.",
+  "A reversal counts whether the user or the agent made it. Ignore rewording that leaves the decision intact.",
+  "Output one line per reversal: SUPERSEDED: <what was concluded earlier> -> <what replaced it> (<why>)",
+  "Report the most decisive reversals first and stay under 200 words \u2014 a list that runs long will be discarded whole, so prioritise rather than pad.",
+  "If nothing was reversed, reply with exactly: NONE"
+].join("\n");
+var COMPACT_SYSTEM_PROMPT = [
+  "You compress one slice of a coding-agent conversation. A later pass will distill the whole thing into an intent brief for a code reviewer.",
+  "You are told which slice of how many this is. Other slices are compressed separately and you cannot see them, so never present a conclusion here as final \u2014 a later slice may overturn it.",
+  "Preserve, in this order of priority:",
+  "1. Reversals and corrections \u2014 any conclusion that was dropped, replaced, or corrected. Quote the deciding sentence verbatim.",
+  "2. Constraints and decisions the user stated, and approaches that were rejected, with the reason.",
+  "3. Behaviour established by actually running something: observed output, exit codes, error text, which stream an error arrived on.",
+  "4. Trade-offs that were acknowledged and accepted.",
+  "Drop: exploration narrative, restated background, tool mechanics, and anything a reviewer could recover by reading the code.",
+  "Stay under 800 words. An over-long slice is discarded whole rather than cut short, so drop lower-priority material instead of running over.",
+  "Keep the conversation's own language. Reply with the compressed slice only, no preamble."
+].join("\n");
+function timeoutForInput(chars) {
+  return Math.min(MAX_TIMEOUT_MS, BASE_TIMEOUT_MS + Math.floor(chars / 1e3) * TIMEOUT_MS_PER_1K_CHARS);
+}
+function isSizeRelatedFailure(error48) {
+  const err = error48;
+  if (err?.name === "AbortError" || err?.name === "TimeoutError") return true;
+  const message = err?.message ?? "";
+  return /context[ _-]?length|maximum context|too many tokens|token limit|prompt is too long|request too large|timed? ?out/i.test(
+    message
+  );
 }
-function serializeConversationForBrief(messages) {
-  const lines = [];
+function withinLimit(text2, max, label) {
+  if (text2.length <= max) return true;
+  console.warn(`[ReviewBrief] ${label} ran to ${text2.length} chars (limit ${max}) \u2014 discarding rather than truncating`);
+  return false;
+}
+function capMessage(text2) {
+  return text2.length > PER_MESSAGE_MAX_CHARS ? text2.slice(0, PER_MESSAGE_MAX_CHARS) + "\u2026" : text2;
+}
+function toEntries(messages) {
+  const entries = [];
   for (const msg of messages) {
     if (!msg) continue;
     if (msg.type === "user" && !msg.event) {
       const text2 = extractUserText(msg.content).trim();
-      if (text2) lines.push(`User: ${capText(text2, PER_MESSAGE_MAX_CHARS)}`);
+      if (text2) entries.push({ role: "User", text: capMessage(text2) });
     } else if (msg.type === "assistant" && typeof msg.content === "string") {
       const text2 = msg.content.trim();
-      if (text2) lines.push(`Agent: ${capText(text2, PER_MESSAGE_MAX_CHARS)}`);
+      if (text2) entries.push({ role: "Agent", text: capMessage(text2) });
     }
   }
-  const full = lines.join("\n\n");
-  if (full.length <= TOTAL_INPUT_MAX_CHARS) return full;
-  return `${full.slice(0, HEAD_CHARS)}
+  return entries;
+}
+function render(entry) {
+  return `${entry.role}: ${entry.text}`;
+}
+function renderAll(entries) {
+  return entries.map(render).join(SEP);
+}
+function serializeConversationForBrief(messages) {
+  return renderAll(toEntries(messages));
+}
+function splitRecent(entries, maxChars) {
+  let size = 0;
+  let i = entries.length;
+  while (i > 0) {
+    const len = render(entries[i - 1]).length + SEP.length;
+    if (size + len > maxChars) break;
+    size += len;
+    i--;
+  }
+  return { older: entries.slice(0, i), recent: entries.slice(i) };
+}
+function chunkEntries(entries, maxChars) {
+  const chunks = [];
+  let current = [];
+  let size = 0;
+  for (const entry of entries) {
+    const len = render(entry).length + SEP.length;
+    if (current.length > 0 && size + len > maxChars) {
+      chunks.push(current);
+      current = [];
+      size = 0;
+    }
+    current.push(entry);
+    size += len;
+  }
+  if (current.length > 0) chunks.push(current);
+  return chunks;
+}
+function telemetryFor(functionId, userId) {
+  return userId ? {
+    isEnabled: true,
+    functionId,
+    metadata: { userId, tags: ["vibedeckx", functionId] }
+  } : void 0;
+}
+async function compactChunk(model, chunk, part, total, userId) {
+  try {
+    const result = await generateText({
+      model,
+      system: COMPACT_SYSTEM_PROMPT,
+      prompt: `Slice ${part} of ${total}.
+
+${chunk}`,
+      timeout: timeoutForInput(chunk.length),
+      maxOutputTokens: COMPACT_SUMMARY_MAX_TOKENS,
+      experimental_telemetry: telemetryFor("review-intent-brief-compact", userId)
+    });
+    const text2 = (result.text ?? "").trim();
+    if (text2.length === 0) return null;
+    return withinLimit(text2, COMPACT_SUMMARY_MAX_CHARS, `slice ${part}/${total} summary`) ? text2 : null;
+  } catch (error48) {
+    if (isSizeRelatedFailure(error48)) throw error48;
+    console.warn(`[ReviewBrief] compaction of slice ${part}/${total} failed:`, error48.message);
+    return null;
+  }
+}
+async function compactConversation(model, messages, options = {}) {
+  const sliceChars = options.sliceChars ?? COMPACT_SLICE_BUDGETS[0];
+  const recentChars = Math.max(MIN_RECENT_VERBATIM_CHARS, Math.floor(sliceChars * RECENT_VERBATIM_RATIO));
+  const entries = toEntries(messages);
+  if (entries.length === 0) return null;
+  const { older, recent } = splitRecent(entries, recentChars);
+  if (older.length === 0) return null;
+  const chunks = chunkEntries(older, sliceChars);
+  if (chunks.length > MAX_FOLD_CALLS) {
+    console.warn(
+      `[ReviewBrief] conversation needs ${chunks.length} slices of ${sliceChars} chars (max ${MAX_FOLD_CALLS}) \u2014 falling back to tier 2`
+    );
+    return null;
+  }
+  const settled = await Promise.allSettled(
+    chunks.map((chunk, i) => compactChunk(model, renderAll(chunk), i + 1, chunks.length, options.userId))
+  );
+  const sizeRejection = settled.find((r) => r.status === "rejected" && isSizeRelatedFailure(r.reason));
+  if (sizeRejection) throw sizeRejection.reason;
+  if (settled.some((r) => r.status === "rejected" || r.value === null)) return null;
+  const parts = settled.map(
+    (r, i) => `[Compressed slice ${i + 1} of ${chunks.length}]
+${r.value}`
+  );
+  if (recent.length > 0) parts.push(`[Recent turns, verbatim]
+${renderAll(recent)}`);
+  return parts.join(SEP);
+}
+function buildBriefPrompt(conversation, reversals) {
+  const preamble = reversals ? "Conclusions this conversation reversed. The right-hand side is the current state \u2014 never report the left-hand side as what was decided:\n" + reversals + SEP : "";
+  return `${preamble}Distill this conversation into an intent brief:
 
-[\u2026 middle of the conversation omitted \u2026]
+${conversation}`;
+}
+function appendCompactionNote(brief, compacted) {
+  return compacted ? `${brief}${SEP}${COMPACTION_NOTE}` : brief;
+}
+async function extractReversalsWithModel(model, conversation, options = {}) {
+  if (conversation.trim().length < REVERSAL_MIN_CHARS) return null;
+  try {
+    const result = await generateText({
+      model,
+      system: REVERSAL_SYSTEM_PROMPT,
+      prompt: `Report the reversals in this conversation:
 
-${full.slice(-TAIL_CHARS)}`;
+${conversation}`,
+      timeout: timeoutForInput(conversation.length),
+      maxOutputTokens: REVERSALS_MAX_TOKENS,
+      experimental_telemetry: telemetryFor("review-intent-brief-reversals", options.userId)
+    });
+    const text2 = (result.text ?? "").trim();
+    if (text2.length === 0 || /^none\b/i.test(text2)) return null;
+    return withinLimit(text2, REVERSALS_MAX_CHARS, "reversal list") ? text2 : null;
+  } catch (error48) {
+    if (!isSizeRelatedFailure(error48)) throw error48;
+    console.warn("[ReviewBrief] reversal pass hit a size limit \u2014 skipping it:", error48.message);
+    return null;
+  }
 }
 async function generateIntentBriefWithModel(model, conversation, options = {}) {
   if (conversation.trim().length === 0) return null;
-  const telemetry = options.userId ? {
-    isEnabled: true,
-    functionId: "review-intent-brief",
-    metadata: {
-      userId: options.userId,
-      tags: ["vibedeckx", "review-intent-brief"]
-    }
-  } : void 0;
   try {
     const result = await generateText({
       model,
       system: SYSTEM_PROMPT2,
-      prompt: `Distill this conversation into an intent brief:
-
-${conversation}`,
-      timeout: AI_TIMEOUT_MS2,
-      experimental_telemetry: telemetry
+      prompt: buildBriefPrompt(conversation, options.reversals ?? null),
+      timeout: timeoutForInput(conversation.length),
+      maxOutputTokens: BRIEF_MAX_TOKENS,
+      experimental_telemetry: telemetryFor("review-intent-brief", options.userId)
     });
     const text2 = (result.text ?? "").trim();
-    return text2.length > 0 ? capText(text2, BRIEF_MAX_CHARS) : null;
+    if (text2.length === 0) return null;
+    return text2.length <= BRIEF_MAX_CHARS ? text2 : text2.slice(0, BRIEF_MAX_CHARS) + BRIEF_TRUNCATION_NOTE;
   } catch (error48) {
+    if (options.rethrowSizeFailures && isSizeRelatedFailure(error48)) throw error48;
     console.warn("[ReviewBrief] AI generation failed:", error48.message);
     return null;
   }
 }
+async function distill(model, conversation, userId, rethrowSizeFailures) {
+  const reversals = await extractReversalsWithModel(model, conversation, { userId });
+  return generateIntentBriefWithModel(model, conversation, { userId, reversals, rethrowSizeFailures });
+}
 async function generateIntentBrief(storage, userId, messages) {
   try {
     if (!await isChatModelConfigured(storage, userId)) return null;
     const conversation = serializeConversationForBrief(messages);
     if (!conversation) return null;
-    return await generateIntentBriefWithModel(await resolveFastChatModel(storage, userId), conversation, { userId });
+    const model = await resolveFastChatModel(storage, userId);
+    if (conversation.length <= COMPACT_TRIGGER_CHARS) {
+      try {
+        const brief = await distill(model, conversation, userId, true);
+        return brief === null ? null : appendCompactionNote(brief, false);
+      } catch (error48) {
+        if (!isSizeRelatedFailure(error48)) throw error48;
+        console.warn("[ReviewBrief] full conversation rejected as too large \u2014 compacting and retrying");
+      }
+    }
+    for (const sliceChars of COMPACT_SLICE_BUDGETS) {
+      try {
+        const compacted = await compactConversation(model, messages, { userId, sliceChars });
+        if (compacted === null) return null;
+        const brief = await distill(model, compacted, userId, true);
+        return brief === null ? null : appendCompactionNote(brief, true);
+      } catch (error48) {
+        if (!isSizeRelatedFailure(error48)) throw error48;
+        console.warn(`[ReviewBrief] ${sliceChars}-char slices still too large \u2014 retrying smaller`);
+      }
+    }
+    console.warn("[ReviewBrief] could not compact the conversation small enough \u2014 falling back to tier 2");
+    return null;
   } catch (error48) {
     console.warn("[ReviewBrief] generation failed:", error48.message);
     return null;
@@ -236515,7 +237879,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 +237963,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 +238002,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 +238016,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 +238135,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 +238330,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 +238397,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 +238671,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 +238716,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 +238997,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 +239384,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 +239500,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 +239511,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 +239569,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 +239597,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 +239780,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 +239855,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 +240354,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 +240525,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 +240608,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 +240716,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 +240822,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 +240945,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 +240964,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 +241136,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 +241340,8 @@ var searchRoutes = async (fastify2) => {
           target.projectId,
           target.targetId,
           s3.id,
-          mapBranch
+          mapBranch,
+          "from_now"
         );
         return { ...s3, id: localSessionId };
       }));
@@ -239996,6 +241378,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 +241466,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 +241754,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 +242643,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 +242703,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 +245046,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 +245056,7 @@ var routes30 = buildRouteMap({
     brief: "Vibedeckx - AI-powered app generator"
   }
 });
-var program = buildApplication(routes30, {
+var program = buildApplication(routes32, {
   name: "vibedeckx",
   versionInfo: {
     currentVersion: readPackageVersion()