fix(schedules): clean up orphaned schedule records when repo is deleted (#255)

* fix(schedules): clean up orphaned schedule records and add schedule URL state management

* refactor(schedules): consolidate schedule tab state into useScheduleUrlState

* fix(schedules): cascade delete schedule runs/jobs and preserve assistant schedules in orphan cleanup

* refactor(schedules): replace deleteJobsByRepo with prepareRepoDelete, add lightweight ID query, remove dead mock

* refactor(schedules): consolidate PromptTemplateDialog form state into single object

Author: chriswritescode-dev

backend/src/db/queries.ts

@@ -209,7 +209,8 @@ export function updateRepoBranch(db: Database, id: number, branch: string): void
 }
 
 export function deleteRepo(db: Database, id: number): void {
+  db.prepare('DELETE FROM schedule_runs WHERE repo_id = ?').run(id)
+  db.prepare('DELETE FROM schedule_jobs WHERE repo_id = ?').run(id)
   const stmt = db.prepare('DELETE FROM repos WHERE id = ?')
   stmt.run(id)
 }
-

backend/src/db/schedules.ts

@@ -116,6 +116,12 @@ export function listScheduleJobsByRepo(db: Database, repoId: number): ScheduleJo
   return rows.map(rowToScheduleJob)
 }
 
+export function listScheduleJobIdsByRepo(db: Database, repoId: number): number[] {
+  const stmt = db.prepare('SELECT id FROM schedule_jobs WHERE repo_id = ? ORDER BY created_at DESC')
+  const rows = stmt.all(repoId) as Array<{ id: number }>
+  return rows.map((row) => row.id)
+}
+
 export function listEnabledScheduleJobs(db: Database): ScheduleJob[] {
   const stmt = db.prepare('SELECT * FROM schedule_jobs WHERE enabled = 1 ORDER BY id ASC')
   const rows = stmt.all() as ScheduleJobRow[]
@@ -200,11 +206,29 @@ export function updateScheduleJob(db: Database, repoId: number, jobId: number, i
 }
 
 export function deleteScheduleJob(db: Database, repoId: number, jobId: number): boolean {
+  db.prepare('DELETE FROM schedule_runs WHERE repo_id = ? AND job_id = ?').run(repoId, jobId)
   const stmt = db.prepare('DELETE FROM schedule_jobs WHERE repo_id = ? AND id = ?')
   const result = stmt.run(repoId, jobId)
   return result.changes > 0
 }
 
+export function cleanupOrphanedSchedules(db: Database): { orphanedJobs: number; orphanedRuns: number } {
+  const runStmt = db.prepare(`
+    DELETE FROM schedule_runs
+    WHERE (repo_id != ? AND repo_id NOT IN (SELECT id FROM repos))
+       OR job_id NOT IN (SELECT id FROM schedule_jobs)
+  `)
+  const orphanedRuns = runStmt.run(ASSISTANT_REPO_ID).changes
+
+  const jobStmt = db.prepare(`
+    DELETE FROM schedule_jobs
+    WHERE repo_id != ? AND repo_id NOT IN (SELECT id FROM repos)
+  `)
+  const orphanedJobs = jobStmt.run(ASSISTANT_REPO_ID).changes
+
+  return { orphanedJobs, orphanedRuns }
+}
+
 export function updateScheduleJobRunState(db: Database, repoId: number, jobId: number, values: { lastRunAt: number; nextRunAt?: number | null }): void {
   const stmt = db.prepare('UPDATE schedule_jobs SET last_run_at = ?, next_run_at = ?, updated_at = ? WHERE repo_id = ? AND id = ?')
   stmt.run(values.lastRunAt, values.nextRunAt ?? null, Date.now(), repoId, jobId)

backend/src/routes/repos.test.ts

@@ -37,6 +37,7 @@ function createTestApp(db: Database, openCodeClient: OpenCodeClient = createStub
     listSchedules: () => [],
     updateSchedule: () => {},
     deleteSchedule: () => {},
+    prepareRepoDelete: () => {},
   } as any
   app.route('/repos', createRepoRoutes(db, stubGitAuthService, scheduleService, openCodeClient))
   return app

backend/src/routes/repos.ts

@@ -273,6 +273,8 @@ app.get('/', async (c) => {
         return c.json({ error: 'Repo not found' }, 404)
       }
 
+      scheduleService.prepareRepoDelete(id)
+      
       await repoService.deleteRepoFiles(database, id)
 
       return c.json({ success: true })

backend/src/services/schedules.ts

@@ -10,6 +10,7 @@ import {
 import { getRepoById } from '../db/queries'
 import type { ScheduleJobWithRepo } from '../db/schedules'
 import {
+  cleanupOrphanedSchedules,
   createScheduleJob,
   createScheduleRun,
   deleteScheduleJob,
@@ -19,6 +20,7 @@ import {
   listAllScheduleJobsWithRepos,
   listAllScheduleRuns,
   listEnabledScheduleJobs,
+  listScheduleJobIdsByRepo,
   listScheduleJobsByRepo,
   listRunningScheduleRuns,
   listScheduleRunsByJob,
@@ -444,6 +446,26 @@ export class ScheduleService {
     this.onJobChange?.(null, jobId)
   }
 
+  prepareRepoDelete(repoId: number): void {
+    const jobIds = listScheduleJobIdsByRepo(this.db, repoId)
+    for (const jobId of jobIds) {
+      this.onJobChange?.(null, jobId)
+    }
+  }
+
+  /**
+   * Removes any schedule_jobs and schedule_runs whose repo_id (or job_id for
+   * runs) no longer exists in the repos / schedule_jobs table.  Safe to call
+   * on every startup — no-op when there are no orphans.
+   */
+  cleanupOrphanedSchedules(): { orphanedJobs: number; orphanedRuns: number } {
+    const result = cleanupOrphanedSchedules(this.db)
+    if (result.orphanedJobs > 0 || result.orphanedRuns > 0) {
+      logger.info(`Cleaned up ${result.orphanedJobs} orphaned schedule job(s) and ${result.orphanedRuns} run(s)`)
+    }
+    return result
+  }
+
   listRuns(repoId: number, jobId: number, limit: number = 20): ScheduleRun[] {
     this.assertJob(repoId, jobId)
     return listScheduleRunsByJob(this.db, repoId, jobId, limit)
@@ -1120,6 +1142,11 @@ export class ScheduleRunner {
       }
     })
 
+    // Clean up any schedule records whose repo no longer exists.  This handles
+    // leftovers from before foreign-key enforcement was enabled, and guards
+    // against edge cases where a repo row was removed outside the normal flow.
+    this.scheduleService.cleanupOrphanedSchedules()
+
     await this.scheduleService.recoverRunningRuns()
     this.registerAllEnabledJobs()
   }

backend/test/db/queries.test.ts

@@ -258,18 +258,31 @@ describe('Database Queries', () => {
   })
 
   describe('deleteRepo', () => {
-    it('should delete repo by ID', () => {
-      const stmt = {
+    it('should delete repo schedules before deleting repo by ID', () => {
+      const deleteRunsStmt = {
+        run: vi.fn().mockReturnValue({ changes: 2 })
+      }
+      const deleteJobsStmt = {
         run: vi.fn().mockReturnValue({ changes: 1 })
       }
-      mockDb.prepare.mockReturnValue(stmt)
+      const deleteRepoStmt = {
+        run: vi.fn().mockReturnValue({ changes: 1 })
+      }
+      mockDb.prepare
+        .mockReturnValueOnce(deleteRunsStmt)
+        .mockReturnValueOnce(deleteJobsStmt)
+        .mockReturnValueOnce(deleteRepoStmt)
 
       db.deleteRepo(mockDb, 1)
 
-      expect(mockDb.prepare).toHaveBeenCalledWith(
+      expect(mockDb.prepare).toHaveBeenNthCalledWith(1, 'DELETE FROM schedule_runs WHERE repo_id = ?')
+      expect(deleteRunsStmt.run).toHaveBeenCalledWith(1)
+      expect(mockDb.prepare).toHaveBeenNthCalledWith(2, 'DELETE FROM schedule_jobs WHERE repo_id = ?')
+      expect(deleteJobsStmt.run).toHaveBeenCalledWith(1)
+      expect(mockDb.prepare).toHaveBeenNthCalledWith(3,
         'DELETE FROM repos WHERE id = ?'
       )
-      expect(stmt.run).toHaveBeenCalledWith(1)
+      expect(deleteRepoStmt.run).toHaveBeenCalledWith(1)
     })
   })
 

backend/test/db/schedules-assistant.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 {
+  cleanupOrphanedSchedules,
   listAllScheduleJobsWithRepos,
   listAllScheduleRuns,
 } from '../../src/db/schedules'
@@ -101,4 +102,14 @@ describe('assistant repo (repo_id=0) in global aggregate queries', () => {
     expect(run.repoName).toBe('Assistant')
     expect(run.repoPath).toBe('assistant')
   })
+
+  it('cleanupOrphanedSchedules keeps assistant schedules while deleting real repo orphans', () => {
+    db.exec('DELETE FROM repos WHERE id = 1')
+
+    const result = cleanupOrphanedSchedules(db)
+
+    expect(result).toEqual({ orphanedJobs: 1, orphanedRuns: 1 })
+    expect(listAllScheduleJobsWithRepos(db).map((job) => job.repoId)).toEqual([0])
+    expect(listAllScheduleRuns(db, {}).map((run) => run.repoId)).toEqual([0])
+  })
 })

backend/test/db/schedules.test.ts

@@ -72,6 +72,19 @@ describe('schedule database queries', () => {
     })
   })
 
+  it('lists schedule job ids without loading full job rows', () => {
+    const stmt = {
+      all: vi.fn().mockReturnValue([{ id: 7 }, { id: 8 }]),
+    }
+    mockDb.prepare.mockReturnValue(stmt)
+
+    const jobIds = schedulesDb.listScheduleJobIdsByRepo(mockDb, 42)
+
+    expect(mockDb.prepare).toHaveBeenCalledWith('SELECT id FROM schedule_jobs WHERE repo_id = ? ORDER BY created_at DESC')
+    expect(stmt.all).toHaveBeenCalledWith(42)
+    expect(jobIds).toEqual([7, 8])
+  })
+
   it('creates a schedule job and reloads the inserted row', () => {
     const insertStmt = {
       run: vi.fn().mockReturnValue({ lastInsertRowid: 7 }),
@@ -173,6 +186,27 @@ describe('schedule database queries', () => {
     })
   })
 
+  it('deletes schedule runs before deleting a schedule job', () => {
+    const deleteRunsStmt = {
+      run: vi.fn().mockReturnValue({ changes: 2 }),
+    }
+    const deleteJobStmt = {
+      run: vi.fn().mockReturnValue({ changes: 1 }),
+    }
+
+    mockDb.prepare
+      .mockReturnValueOnce(deleteRunsStmt)
+      .mockReturnValueOnce(deleteJobStmt)
+
+    const deleted = schedulesDb.deleteScheduleJob(mockDb, 42, 7)
+
+    expect(mockDb.prepare).toHaveBeenNthCalledWith(1, 'DELETE FROM schedule_runs WHERE repo_id = ? AND job_id = ?')
+    expect(deleteRunsStmt.run).toHaveBeenCalledWith(42, 7)
+    expect(mockDb.prepare).toHaveBeenNthCalledWith(2, 'DELETE FROM schedule_jobs WHERE repo_id = ? AND id = ?')
+    expect(deleteJobStmt.run).toHaveBeenCalledWith(42, 7)
+    expect(deleted).toBe(true)
+  })
+
   it('returns null when updating metadata for a missing run', () => {
     const selectStmt = {
       get: vi.fn().mockReturnValue(undefined),

backend/test/services/schedules.test.ts

@@ -6,11 +6,13 @@ const mocks = vi.hoisted(() => ({
   createScheduleJob: vi.fn(),
   createScheduleRun: vi.fn(),
   deleteScheduleJob: vi.fn(),
+  cleanupOrphanedSchedules: vi.fn(),
   getScheduleJobById: vi.fn(),
   getRunningScheduleRunByJob: vi.fn(),
   getScheduleRunById: vi.fn(),
   listEnabledScheduleJobs: vi.fn(),
   listRunningScheduleRuns: vi.fn(),
+  listScheduleJobIdsByRepo: vi.fn(),
   listScheduleJobsByRepo: vi.fn(),
   listScheduleRunsByJob: vi.fn(),
   updateScheduleJob: vi.fn(),
@@ -35,11 +37,13 @@ vi.mock('../../src/db/schedules', () => ({
   createScheduleJob: mocks.createScheduleJob,
   createScheduleRun: mocks.createScheduleRun,
   deleteScheduleJob: mocks.deleteScheduleJob,
+  cleanupOrphanedSchedules: mocks.cleanupOrphanedSchedules,
   getScheduleJobById: mocks.getScheduleJobById,
   getRunningScheduleRunByJob: mocks.getRunningScheduleRunByJob,
   getScheduleRunById: mocks.getScheduleRunById,
   listEnabledScheduleJobs: mocks.listEnabledScheduleJobs,
   listRunningScheduleRuns: mocks.listRunningScheduleRuns,
+  listScheduleJobIdsByRepo: mocks.listScheduleJobIdsByRepo,
   listScheduleJobsByRepo: mocks.listScheduleJobsByRepo,
   listScheduleRunsByJob: mocks.listScheduleRunsByJob,
   updateScheduleJob: mocks.updateScheduleJob,
@@ -724,6 +728,20 @@ describe('ScheduleService', () => {
     expect(() => service.getRun(42, 7, 5)).toThrow('Run not found')
   })
 
+  it('prepares repo deletion by unregistering repo jobs without deleting records', () => {
+    const service = new ScheduleService({} as never, createOpenCodeClientStub())
+    const onJobChange = vi.fn()
+    service.setJobChangeHandler(onJobChange)
+    mocks.listScheduleJobIdsByRepo.mockReturnValue([7, 8])
+
+    service.prepareRepoDelete(42)
+
+    expect(mocks.listScheduleJobIdsByRepo).toHaveBeenCalledWith(expect.anything(), 42)
+    expect(onJobChange).toHaveBeenCalledWith(null, 7)
+    expect(onJobChange).toHaveBeenCalledWith(null, 8)
+    expect(onJobChange).toHaveBeenCalledTimes(2)
+  })
+
   it('cancels by finalizing the run when the assistant already completed', async () => {
     const service = new ScheduleService({} as never, createOpenCodeClientStub())
     const runningRun: ScheduleRun = {
@@ -998,6 +1016,7 @@ describe('ScheduleRunner', () => {
   beforeEach(() => {
     mockCronInstances.length = 0
     mockCronStop.mockClear()
+    mocks.cleanupOrphanedSchedules.mockReturnValue({ orphanedJobs: 0, orphanedRuns: 0 })
   })
 
   it('recovers running runs and registers all enabled jobs on start', async () => {

frontend/src/components/navigation/MobileTabBar.tsx

@@ -3,7 +3,8 @@ import { useLocation, useNavigate } from 'react-router-dom'
 import { FolderGit2, FolderOpen, CalendarClock, Menu, Info, History, Bot } from 'lucide-react'
 import { cn } from '@/lib/utils'
 import { useMobile } from '@/hooks/useMobile'
-import { useMobileTabBar, useScheduleTab, type ScheduleTabKey } from '@/hooks/useMobileTabBar'
+import { useMobileTabBar } from '@/hooks/useMobileTabBar'
+import { useScheduleUrlState, type ScheduleTab } from '@/hooks/useScheduleUrlState'
 import { useUIState } from '@/stores/uiStateStore'
 import { getAssistantPath, isAssistantPath } from '@/lib/navigation'
 
@@ -124,7 +125,7 @@ function buildGlobalTabs({ pathname, search, openSheet, open, close, navigate, i
   ]
 }
 
-function buildScheduleTabs(scheduleTab: ScheduleTabKey, setScheduleTab: (tab: ScheduleTabKey) => void): TabDef[] {
+function buildScheduleTabs(scheduleTab: ScheduleTab, setScheduleTab: (tab: ScheduleTab) => void): TabDef[] {
   return [
     {
       key: 'jobs',
@@ -189,7 +190,7 @@ export const MobileTabBar = memo(function MobileTabBar() {
   const { pathname, search } = useLocation()
   const navigate = useNavigate()
   const { openSheet, open, close } = useMobileTabBar()
-  const { scheduleTab, setScheduleTab } = useScheduleTab()
+  const { scheduleTab, setScheduleTab } = useScheduleUrlState()
   const isMobile = useMobile()
   const isMoreDrawerOpen = useUIState((state) => state.isMoreDrawerOpen)
   const setMoreDrawerOpen = useUIState((state) => state.setMoreDrawerOpen)