fix(schedules): open report links in place and route schedule notifications to the run report

backend/src/db/schedules.ts

@@ -460,6 +460,12 @@ export function getScheduleRunById(db: Database, repoId: number, jobId: number,
   return row ? rowToScheduleRun(row) : null
 }
 
+export function getScheduleRunBySessionId(db: Database, sessionId: string): ScheduleRun | null {
+  const stmt = db.prepare('SELECT * FROM schedule_runs WHERE session_id = ? ORDER BY started_at DESC LIMIT 1')
+  const row = stmt.get(sessionId) as ScheduleRunRow | undefined
+  return row ? rowToScheduleRun(row) : null
+}
+
 export function getRunningScheduleRunByJob(db: Database, repoId: number, jobId: number): ScheduleRun | null {
   const stmt = db.prepare(`
     SELECT * FROM schedule_runs

backend/src/routes/internal/notifications.ts

@@ -40,7 +40,7 @@ export function createInternalNotificationRoutes(notificationService: Notificati
       timestamp: Date.now(),
       data: {
         eventType: 'assistant.message',
-        url: parsed.data.url ?? '/',
+        url: notificationService.getScheduleRunReportUrl(parsed.data.sessionId) ?? parsed.data.url ?? '/',
         priority: parsed.data.priority,
       },
     }

backend/src/services/assistant-mode.ts

@@ -569,6 +569,7 @@ Sending is rate limited to **10 notifications per minute**. Beyond that the tool
 - Notifications are only sent if the user has registered devices (browser push subscriptions)
 - If VAPID is not configured on the server, the tool fails with a \`503\` status
 - Use \`priority: 'high'\` for urgent notifications that should interrupt the user
+- In a scheduled run, the notification always opens that run's report, so \`url\` is not needed
 - Do not call the internal HTTP API with \`curl\` for notifications; the tool is the supported path
 `
 }

backend/src/services/notification.ts

@@ -20,6 +20,7 @@ import {
   getRepoName,
   listRepos,
 } from "../db/queries";
+import { getScheduleRunBySessionId } from "../db/schedules";
 import type { Repo } from "../types/repo";
 import { getReposPath } from "@opencode-manager/shared/config/env";
 import { ASSISTANT_REPO_ID } from "@opencode-manager/shared/utils";
@@ -71,13 +72,22 @@ const EVENT_CONFIG: Record<
 
 const MAX_BODY_LENGTH = 140;
 
+const RUN_OUTCOME_EVENTS = new Set<string>([
+  NotificationEventType.SESSION_IDLE,
+  NotificationEventType.SESSION_FAILED,
+]);
+
 function resolveEventSessionId(event: SSEEvent): string | undefined {
   if (event.type === NotificationEventType.FORM_CREATED) {
     return event.data.form.sessionID;
   }
   return sessionIDFromEvent(event);
 }
 
+export function buildScheduleRunReportUrl(runId: number): string {
+  return `/schedules?scheduleTab=runs&runId=${runId}`;
+}
+
 export function buildNotificationUrl(
   repo: Pick<Repo, "id"> | null,
   sessionId: string | undefined
@@ -272,6 +282,13 @@ export class NotificationService {
     return rows.map((r) => r.user_id);
   }
 
+  /** Returns the run report URL when the session was started by a scheduled run. */
+  getScheduleRunReportUrl(sessionId: string | undefined): string | null {
+    if (!sessionId) return null;
+    const run = getScheduleRunBySessionId(this.db, sessionId);
+    return run ? buildScheduleRunReportUrl(run.id) : null;
+  }
+
   private async resolveRepoForDirectory(directory: string): Promise<Repo | null> {
     const repo =
       getRepoBySourcePath(this.db, path.resolve(directory)) ??
@@ -312,7 +329,8 @@ export class NotificationService {
     const repo = directory ? await this.resolveRepoForDirectory(directory) : null;
     const repoId = repo?.id;
     const repoName = repo ? getRepoName(repo) : undefined;
-    const url = buildNotificationUrl(repo, sessionId);
+    const reportUrl = RUN_OUTCOME_EVENTS.has(event.type) ? this.getScheduleRunReportUrl(sessionId) : null;
+    const url = reportUrl ?? buildNotificationUrl(repo, sessionId);
 
     const payload = buildEventNotificationPayload(event, {
       repoName,

backend/src/services/opencode-manager-tool-plugin.ts

@@ -198,18 +198,19 @@ async function postInternalApi(routePath, body, signal) {
 
 var ACTIONS = {
   send_notification: {
-    run: async function (params, signal) {
-      var result = await postInternalApi('/notifications/send', params, signal)
+    run: async function (params, context) {
+      var body = Object.assign({}, params, { sessionId: context.sessionID })
+      var result = await postInternalApi('/notifications/send', body, context.signal)
       if (result.noSubscriptions === true) {
         return 'No devices are registered for push notifications, so nothing was delivered.'
       }
       return 'Notification sent: ' + (result.delivered || 0) + ' delivered, ' + (result.failed || 0) + ' failed.'
     },
   },
   request: {
-    run: async function (params, signal) {
+    run: async function (params, context) {
       assertAllowedRoute(params.method, params.path)
-      var text = await requestInternalApi(params.method, params.path, params.body, signal)
+      var text = await requestInternalApi(params.method, params.path, params.body, context.signal)
       return text || 'The request succeeded with an empty response body.'
     },
   },
@@ -229,14 +230,14 @@ function assertParams(actionName, params) {
   }
 }
 
-async function runAction(input, signal) {
+async function runAction(input, context) {
   var actionName = input !== null && typeof input === 'object' ? input.action : undefined
   if (!Object.prototype.hasOwnProperty.call(ACTIONS, actionName)) {
     throw new Error('Unknown OpenCode Manager action: ' + String(actionName) + '. Supported actions: ' + ACTION_NAMES.join(', ') + '.')
   }
   var params = input.params
   assertParams(actionName, params)
-  return await ACTIONS[actionName].run(params, signal)
+  return await ACTIONS[actionName].run(params, context)
 }
 
 export default {
@@ -249,7 +250,7 @@ export default {
         input: INPUT_SCHEMA,
         options: { codemode: false },
         execute: async function (input, context) {
-          return { content: await runAction(input, context.signal) }
+          return { content: await runAction(input, context) }
         },
       })
     })

backend/test/routes/internal-notifications.test.ts

@@ -9,6 +9,7 @@ import { createOpenCodeClient } from '../../src/services/opencode/client'
 import { allMigrations } from '../../src/db/migrations'
 import { getOrCreateInternalToken } from '../../src/services/internal-token'
 import { migrate } from '../../src/db/migration-runner'
+import { createScheduleRun, updateScheduleRunMetadata } from '../../src/db/schedules'
 import type { ScheduleWorktreeManager } from '../../src/services/schedule-worktree'
 
 describe('internal/notifications routes', () => {
@@ -142,6 +143,42 @@ describe('internal/notifications routes', () => {
     expect(res.status).toBe(400)
   })
 
+  describe('notification url', () => {
+    const send = (payload: Record<string, unknown>) =>
+      app.request('/api/internal/notifications/send', {
+        method: 'POST',
+        body: JSON.stringify({ title: 'Test', body: 'Body', ...payload }),
+        headers: { 'content-type': 'application/json', authorization: `Bearer ${token}` },
+      })
+
+    const sentUrl = (sendToUser: ReturnType<typeof vi.spyOn>) =>
+      (sendToUser.mock.calls[0]?.[1] as { data: { url: string } }).data.url
+
+    beforeEach(() => {
+      vi.spyOn(notificationService, 'isConfigured').mockReturnValue(true)
+    })
+
+    it('links a scheduled run session to its run report, even when the agent passes a url', async () => {
+      db.exec('PRAGMA foreign_keys = OFF')
+      const run = createScheduleRun(db, { jobId: 7, repoId: 0, triggerSource: 'schedule', status: 'running', startedAt: 1, createdAt: 1 })
+      updateScheduleRunMetadata(db, 0, 7, run.id, { sessionId: 'ses_scheduled' })
+      const sendToUser = vi.spyOn(notificationService, 'sendToUser').mockResolvedValue({ delivered: 1, expired: 0, failed: 0, total: 1 })
+
+      const res = await send({ sessionId: 'ses_scheduled', url: '/repos/my-repo' })
+
+      expect(res.status).toBe(200)
+      expect(sentUrl(sendToUser)).toBe(`/schedules?scheduleTab=runs&runId=${run.id}`)
+    })
+
+    it('keeps the agent url for sessions that are not scheduled runs', async () => {
+      const sendToUser = vi.spyOn(notificationService, 'sendToUser').mockResolvedValue({ delivered: 1, expired: 0, failed: 0, total: 1 })
+
+      await send({ sessionId: 'ses_manual', url: '/repos/3' })
+
+      expect(sentUrl(sendToUser)).toBe('/repos/3')
+    })
+  })
+
   it('POST /api/internal/notifications/send returns 429 after 10 calls within rate window', async () => {
     vi.spyOn(notificationService, 'isConfigured').mockReturnValue(true)
     vi.spyOn(notificationService, 'sendToUser').mockResolvedValue({ delivered: 0, expired: 0, failed: 0, total: 0 })

backend/test/services/notification-service.test.ts

@@ -3,6 +3,7 @@ import { Database } from 'bun:sqlite'
 import { migrate } from '../../src/db/migration-runner'
 import { allMigrations } from '../../src/db/migrations'
 import { createRepo } from '../../src/db/queries'
+import { createScheduleRun, updateScheduleRunMetadata } from '../../src/db/schedules'
 import { NotificationService } from '../../src/services/notification'
 import { SettingsService } from '../../src/services/settings'
 import { sseAggregator, type SSEEvent } from '../../src/services/sse-aggregator'
@@ -45,8 +46,7 @@ function permissionAskedEvent(sessionID: string): SSEEvent {
   }
 }
 
-function createService(): NotificationService {
-  const db = new Database(':memory:')
+function createService(db = new Database(':memory:')): NotificationService {
   migrate(db, allMigrations)
   createRepo(db, {
     localPath: 'repo-one',
@@ -128,6 +128,27 @@ describe('NotificationService.handleSSEEvent session routing', () => {
     expect(payload.data?.url).toBe('/repos/1/sessions/ses_perm')
   })
 
+  it('opens the run report for a scheduled session that finishes, but the session for its permission prompts', async () => {
+    const db = new Database(':memory:')
+    const service = createService(db)
+    db.exec('PRAGMA foreign_keys = OFF')
+    const run = createScheduleRun(db, { jobId: 5, repoId: 1, triggerSource: 'schedule', status: 'running', startedAt: 1, createdAt: 1 })
+    updateScheduleRunMetadata(db, 1, 5, run.id, { sessionId: 'ses_sched' })
+    const send = vi.spyOn(service, 'sendToUser').mockResolvedValue(sendResult)
+
+    await service.handleSSEEvent(DIRECTORY, {
+      id: 'evt_idle_1',
+      created: 1700000000000,
+      type: 'session.idle',
+      location: { directory: DIRECTORY },
+      data: { sessionID: 'ses_sched' },
+    } as SSEEvent)
+    await service.handleSSEEvent(DIRECTORY, permissionAskedEvent('ses_sched'))
+
+    const urls = send.mock.calls.map((call) => (call[1] as PushNotificationPayload).data?.url)
+    expect(urls).toEqual([`/schedules?scheduleTab=runs&runId=${run.id}`, '/repos/1/sessions/ses_sched'])
+  })
+
   it('suppresses a permission for a session the user is viewing', async () => {
     const service = createService()
     const send = vi.spyOn(service, 'sendToUser').mockResolvedValue(sendResult)

backend/test/services/opencode-manager-tool-plugin.test.ts

@@ -506,7 +506,12 @@ describe.skipIf(SHIPPED_OPENCODE_BIN === null)('ocm-manager plugin against the s
       expect(apiRequests).toHaveLength(1)
       const request = JSON.parse(apiRequests[0] as string) as { auth: string; body: string }
       expect(request.auth).toBe('Bearer test-token')
-      expect(JSON.parse(request.body)).toEqual({ title: 'Storm watch', body: 'Formation odds crossed 40%', priority: 'high' })
+      expect(JSON.parse(request.body)).toEqual({
+        title: 'Storm watch',
+        body: 'Formation odds crossed 40%',
+        priority: 'high',
+        sessionId: expect.stringMatching(/^ses_/),
+      })
       expect(toolResults.some((output) => output.includes('Notification sent: 1 delivered, 0 failed.'))).toBe(true)
     } finally {
       api.server.close()

frontend/src/components/file-browser/FileBrowserSheet.tsx

@@ -1,4 +1,5 @@
 import { useEffect, useState, memo, useCallback, useRef } from 'react'
+import { createPortal } from 'react-dom'
 import { FileBrowser, type FileBrowserHandle } from './FileBrowser'
 import { getRepoRelativeDisplayPath } from './display-path'
 import { Button } from '@/components/ui/button'
@@ -116,7 +117,7 @@ export const FileBrowserSheet = memo(function FileBrowserSheet({ isOpen, onClose
 
   if (!isOpen && !shouldRender) return null
 
-  return (
+  return createPortal(
     <div
       ref={containerRef}
       className="fixed inset-0 z-50"
@@ -200,6 +201,7 @@ export const FileBrowserSheet = memo(function FileBrowserSheet({ isOpen, onClose
         itemName={downloadDialog?.type === 'directory' ? currentPath.split('/').pop() || 'Directory' : repoName || 'Repository'}
         targetPath={downloadDialog?.type === 'directory' ? currentPath : basePath}
       />
-    </div>
+    </div>,
+    document.body,
   )
 })