feat: schedule worktree isolation for running jobs in isolated worktrees

Author: chriswritescode-dev

backend/src/db/migrations/015-schedule-worktree-isolation.ts

@@ -17,9 +17,6 @@ const migration: Migration = {
     if (!jobColumnNames.has('branch')) {
       db.run('ALTER TABLE schedule_jobs ADD COLUMN branch TEXT')
     }
-    if (!jobColumnNames.has('isolation_mode')) {
-      db.run("ALTER TABLE schedule_jobs ADD COLUMN isolation_mode TEXT NOT NULL DEFAULT 'worktree'")
-    }
 
     const runColumns = db.prepare('PRAGMA table_info(schedule_runs)').all() as ColumnInfo[]
     const runColumnNames = new Set(runColumns.map((c) => c.name))
@@ -36,12 +33,11 @@ const migration: Migration = {
   },
 
   down(db) {
-    // Rebuild schedule_jobs without branch, isolation_mode
+    // Rebuild schedule_jobs without branch
     const jobColumns = db.prepare('PRAGMA table_info(schedule_jobs)').all() as ColumnInfo[]
     const hasBranch = jobColumns.some((c) => c.name === 'branch')
-    const hasIsolationMode = jobColumns.some((c) => c.name === 'isolation_mode')
 
-    if (hasBranch || hasIsolationMode) {
+    if (hasBranch) {
       db.run(`
         CREATE TABLE schedule_jobs_old (
           id INTEGER PRIMARY KEY AUTOINCREMENT,

backend/src/db/schedules.ts

@@ -3,7 +3,6 @@ import {
   ScheduleJobSchema,
   ScheduleRunSchema,
   ScheduleSkillMetadataSchema,
-  type ScheduleIsolationMode,
   type ScheduleJob,
   type ScheduleMode,
   type ScheduleRun,
@@ -28,7 +27,6 @@ interface ScheduleJobRow {
   model: string | null
   skill_metadata: string | null
   branch: string | null
-  isolation_mode: string | null
   created_at: number
   updated_at: number
   last_run_at: number | null
@@ -84,7 +82,6 @@ function rowToScheduleJob(row: ScheduleJobRow): ScheduleJob {
     model: row.model,
     skillMetadata: parseSkillMetadata(row.skill_metadata),
     branch: row.branch,
-    isolationMode: (row.isolation_mode as ScheduleIsolationMode) ?? 'worktree',
     createdAt: row.created_at,
     updatedAt: row.updated_at,
     lastRunAt: row.last_run_at,
@@ -150,10 +147,10 @@ export function createScheduleJob(db: Database, repoId: number, input: ScheduleJ
   const stmt = db.prepare(`
     INSERT INTO schedule_jobs (
       repo_id, name, description, enabled, schedule_mode, interval_minutes, cron_expression, timezone, agent_slug, prompt, model, skill_metadata,
-      branch, isolation_mode,
+      branch,
       created_at, updated_at, last_run_at, next_run_at
     )
-    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
   `)
 
   const result = stmt.run(
@@ -170,7 +167,6 @@ export function createScheduleJob(db: Database, repoId: number, input: ScheduleJ
     input.model ?? null,
     serializeSkillMetadata(input.skillMetadata),
     input.branch,
-    input.isolationMode,
     now,
     now,
     null,
@@ -195,7 +191,7 @@ export function updateScheduleJob(db: Database, repoId: number, jobId: number, i
   const stmt = db.prepare(`
     UPDATE schedule_jobs
     SET name = ?, description = ?, enabled = ?, schedule_mode = ?, interval_minutes = ?, cron_expression = ?, timezone = ?,
-        agent_slug = ?, prompt = ?, model = ?, skill_metadata = ?, branch = ?, isolation_mode = ?, updated_at = ?, next_run_at = ?
+        agent_slug = ?, prompt = ?, model = ?, skill_metadata = ?, branch = ?, updated_at = ?, next_run_at = ?
     WHERE repo_id = ? AND id = ?
   `)
 
@@ -212,7 +208,6 @@ export function updateScheduleJob(db: Database, repoId: number, jobId: number, i
     input.model,
     serializeSkillMetadata(input.skillMetadata),
     input.branch,
-    input.isolationMode,
     now,
     input.nextRunAt,
     repoId,
@@ -229,6 +224,41 @@ export function deleteScheduleJob(db: Database, repoId: number, jobId: number):
   return result.changes > 0
 }
 
+export interface ScheduleRunArtifact {
+  id: number
+  status: ScheduleRunStatus
+  runBranch: string | null
+  worktreePath: string | null
+}
+
+export function listScheduleRunArtifactsByJob(db: Database, repoId: number, jobId: number): ScheduleRunArtifact[] {
+  const rows = db
+    .prepare('SELECT id, status, run_branch, worktree_path FROM schedule_runs WHERE repo_id = ? AND job_id = ? ORDER BY id DESC')
+    .all(repoId, jobId) as { id: number; status: string; run_branch: string | null; worktree_path: string | null }[]
+  return rows.map((row) => ({
+    id: row.id,
+    status: row.status as ScheduleRunStatus,
+    runBranch: row.run_branch,
+    worktreePath: row.worktree_path,
+  }))
+}
+
+export function deleteScheduleRunById(db: Database, repoId: number, jobId: number, runId: number): boolean {
+  const result = db
+    .prepare('DELETE FROM schedule_runs WHERE repo_id = ? AND job_id = ? AND id = ?')
+    .run(repoId, jobId, runId)
+  return result.changes > 0
+}
+
+export function deleteScheduleRunsByIds(db: Database, repoId: number, jobId: number, runIds: number[]): number {
+  if (runIds.length === 0) return 0
+  const placeholders = runIds.map(() => '?').join(', ')
+  const result = db
+    .prepare(`DELETE FROM schedule_runs WHERE repo_id = ? AND job_id = ? AND id IN (${placeholders})`)
+    .run(repoId, jobId, ...runIds)
+  return result.changes
+}
+
 export function cleanupOrphanedSchedules(db: Database): { orphanedJobs: number; orphanedRuns: number } {
   const runStmt = db.prepare(`
     DELETE FROM schedule_runs

backend/src/routes/schedules.ts

@@ -159,6 +159,29 @@ export function createScheduleRoutes(scheduleService: ScheduleService) {
     }
   })
 
+  app.delete('/:jobId/runs', async (c) => {
+    try {
+      const repoId = parseId(c.req.param('id'), 'repo id', ScheduleServiceError)
+      const jobId = parseId(c.req.param('jobId'), 'schedule id', ScheduleServiceError)
+      const result = await scheduleService.clearRunHistory(repoId, jobId)
+      return c.json(result)
+    } catch (error) {
+      return handleServiceError(c, error, 'Failed to clear schedule run history', ScheduleServiceError)
+    }
+  })
+
+  app.delete('/:jobId/runs/:runId', async (c) => {
+    try {
+      const repoId = parseId(c.req.param('id'), 'repo id', ScheduleServiceError)
+      const jobId = parseId(c.req.param('jobId'), 'schedule id', ScheduleServiceError)
+      const runId = parseId(c.req.param('runId'), 'run id', ScheduleServiceError)
+      await scheduleService.deleteRun(repoId, jobId, runId)
+      return c.json({ success: true })
+    } catch (error) {
+      return handleServiceError(c, error, 'Failed to delete schedule run', ScheduleServiceError)
+    }
+  })
+
   return app
 }
 

backend/src/services/repo.ts

@@ -6,7 +6,7 @@ import { createRepo, getRepoByLocalPath, getRepoBySourcePath, getRepoById, updat
 import type { Database } from 'bun:sqlite'
 import type { Repo, CreateRepoInput } from '../types/repo'
 import { logger } from '../utils/logger'
-import { getReposPath } from '@opencode-manager/shared/config/env'
+import { getReposPath, getScheduleWorktreesPath } from '@opencode-manager/shared/config/env'
 import { normalizeRepoDirectoryName, sanitizeRepoDirectoryName, sanitizeBranchForDirectory, normalizeRepoUrlForCompare } from '@opencode-manager/shared/utils'
 import type { GitAuthService } from './git-auth'
 import { isGitHubHttpsUrl, isSSHUrl, normalizeSSHUrl } from '../utils/git-auth'
@@ -1170,6 +1170,7 @@ export async function getSiblingRepos(
     const knownDirectories = new Set(repoSiblings.map((repo) => canonical(repo.fullPath)))
     const targetDirectory = canonical(target.fullPath)
     const reposRoot = canonical(getReposPath())
+    const scheduleWorktreeRoot = canonical(getScheduleWorktreesPath())
 
     const candidates = workspaces.filter((workspace) => {
       if (workspace.projectID !== targetProjectId) return false
@@ -1178,6 +1179,7 @@ export async function getSiblingRepos(
       const workspaceDirectory = canonical(workspace.directory)
       if (workspaceDirectory === targetDirectory) return false
       if (workspaceDirectory === reposRoot) return false
+      if (workspaceDirectory.startsWith(`${scheduleWorktreeRoot}${path.sep}`)) return false
       if (knownDirectories.has(workspaceDirectory)) return false
 
       return true

backend/src/services/schedule-config.ts

@@ -1,7 +1,6 @@
 import { Cron } from 'croner'
 import type {
   CreateScheduleJobRequest,
-  ScheduleIsolationMode,
   ScheduleJob,
   ScheduleMode,
   ScheduleSkillMetadata,
@@ -23,7 +22,6 @@ export interface ScheduleJobPersistenceInput {
   model: string | null
   skillMetadata: ScheduleSkillMetadata | null | undefined
   branch: string | null
-  isolationMode: ScheduleIsolationMode
   nextRunAt: number | null
 }
 
@@ -99,7 +97,6 @@ export function buildCreateSchedulePersistenceInput(input: CreateScheduleJobRequ
     model: input.model?.trim() || null,
     skillMetadata: input.skillMetadata,
     branch: input.branch?.trim() || null,
-    isolationMode: input.isolationMode ?? 'worktree' as const,
   }
 
   const scheduleConfig = input.scheduleMode === 'cron'
@@ -157,7 +154,6 @@ export function buildUpdatedSchedulePersistenceInput(
     model: input.model === undefined ? existing.model : (input.model?.trim() || null),
     skillMetadata: input.skillMetadata !== undefined ? input.skillMetadata : existing.skillMetadata,
     branch: input.branch === undefined ? existing.branch : (input.branch?.trim() || null),
-    isolationMode: input.isolationMode ?? existing.isolationMode,
     nextRunAt,
   }
 }

backend/src/services/schedule-worktree.ts

@@ -1,7 +1,7 @@
 import { existsSync, mkdirSync } from 'node:fs'
 import path from 'path'
 import type { Database } from 'bun:sqlite'
-import { getReposPath } from '@opencode-manager/shared/config/env'
+import { getScheduleWorktreesPath } from '@opencode-manager/shared/config/env'
 import { ASSISTANT_REPO_ID } from '@opencode-manager/shared/utils'
 import type { Repo } from '../types/repo'
 import type { GitAuthService } from './git-auth'
@@ -39,10 +39,9 @@ export class ScheduleWorktreeManager {
 
   async prepare(
     repo: Repo,
-    job: { id: number; isolationMode: string; branch: string | null },
+    job: { id: number; branch: string | null },
     runId: number,
   ): Promise<ScheduleWorktreeContext | null> {
-    if (job.isolationMode === 'inline') return null
     if (repo.id === ASSISTANT_REPO_ID) return null
 
     try {
@@ -58,16 +57,13 @@ export class ScheduleWorktreeManager {
     }
 
     try {
-      const baseEnv = this.gitAuthService.getGitEnvironment(true)
-      const sshEnv = sshSetup ? this.gitAuthService.getSSHEnvironment() : {}
-      const identityEnv = await this.buildIdentityEnv()
-      const env = { ...baseEnv, ...buildRepoEnvForRepo(repo), ...sshEnv, ...identityEnv }
+      const env = await this.buildGitEnv(repo, sshSetup, true)
 
-      await executeCommand(['git', '-C', repo.fullPath, 'fetch', '--all', '--prune'], { env }).catch(() => {})
+      await executeCommand(['git', '-C', repo.fullPath, 'fetch', '--prune', 'origin'], { env }).catch(() => {})
 
       const base = job.branch?.trim() || (await resolveDefaultBranch(repo.fullPath, env))
       const runBranch = `schedule/${job.id}/run-${runId}`
-      const worktreePath = path.join(getReposPath(), '.ocm-schedule-worktrees', `job-${job.id}-run-${runId}`)
+      const worktreePath = path.join(getScheduleWorktreesPath(), `job-${job.id}-run-${runId}`)
 
       mkdirSync(path.dirname(worktreePath), { recursive: true })
 
@@ -98,21 +94,20 @@ export class ScheduleWorktreeManager {
 
     let sshSetup = false
     let env: Record<string, string> | undefined
+    let noChanges = false
 
     try {
       if (repo.repoUrl && isSSHUrl(repo.repoUrl)) {
         await this.gitAuthService.setupSSHForRepoUrl(repo.repoUrl, this.db)
         sshSetup = true
       }
 
-      const baseEnv = this.gitAuthService.getGitEnvironment()
-      const sshEnv = sshSetup ? this.gitAuthService.getSSHEnvironment() : {}
-      const identityEnv = await this.buildIdentityEnv()
-      env = { ...baseEnv, ...buildRepoEnvForRepo(repo), ...sshEnv, ...identityEnv }
+      env = await this.buildGitEnv(repo, sshSetup, false)
 
       const status = await executeCommand(['git', '-C', run.worktreePath, 'status', '--porcelain'], { env }).catch(() => '')
 
       if (!status.trim()) {
+        noChanges = true
         return { commitHash: null }
       }
 
@@ -132,6 +127,9 @@ export class ScheduleWorktreeManager {
     } finally {
       try {
         await removeWorktree(repo.fullPath, run.worktreePath, env)
+        if (noChanges && run.runBranch) {
+          await executeCommand(['git', '-C', repo.fullPath, 'branch', '-D', run.runBranch], env ? { env } : undefined).catch(() => {})
+        }
       } catch (error) {
         logger.error(`Failed to remove worktree ${run.worktreePath}:`, error)
       }
@@ -141,6 +139,36 @@ export class ScheduleWorktreeManager {
     }
   }
 
+  /**
+   * Removes leftover worktrees and deletes the run branches for a set of
+   * finished runs. Used when clearing run history. Branch and worktree removal
+   * are local git operations, so no SSH setup is needed; failures are swallowed
+   * per artifact so one bad entry does not block the rest.
+   */
+  async pruneRunArtifacts(repo: Repo, artifacts: { runBranch: string | null; worktreePath: string | null }[]): Promise<void> {
+    if (artifacts.length === 0) return
+
+    const env = await this.buildGitEnv(repo, false, true)
+
+    for (const artifact of artifacts) {
+      if (artifact.worktreePath) {
+        await removeWorktree(repo.fullPath, artifact.worktreePath, env)
+      }
+    }
+
+    const branches = artifacts.map((a) => a.runBranch).filter((b): b is string => b !== null && b.length > 0)
+    if (branches.length > 0) {
+      await executeCommand(['git', '-C', repo.fullPath, 'branch', '-D', ...branches], { env }).catch(() => {})
+    }
+  }
+
+  private async buildGitEnv(repo: Repo, sshSetup: boolean, silent: boolean): Promise<Record<string, string>> {
+    const baseEnv = this.gitAuthService.getGitEnvironment(silent)
+    const sshEnv = sshSetup ? this.gitAuthService.getSSHEnvironment() : {}
+    const identityEnv = await this.buildIdentityEnv()
+    return { ...baseEnv, ...buildRepoEnvForRepo(repo), ...sshEnv, ...identityEnv }
+  }
+
   private async buildIdentityEnv(): Promise<Record<string, string>> {
     const settings = this.settingsService.getSettings()
     const gitCredentials = this.credentialProvider.getGitCredentials()

backend/src/services/schedules.ts

@@ -14,10 +14,13 @@ import {
   createScheduleJob,
   createScheduleRun,
   deleteScheduleJob,
+  deleteScheduleRunById,
+  deleteScheduleRunsByIds,
   getScheduleJobById,
   getRunningScheduleRunByJob,
   getScheduleRunById,
   listAllScheduleJobsWithRepos,
+  listScheduleRunArtifactsByJob,
   listAllScheduleRuns,
   listEnabledScheduleJobs,
   listScheduleJobIdsByRepo,
@@ -505,6 +508,45 @@ export class ScheduleService {
     return run
   }
 
+  /**
+   * Clears a job's run history: deletes every finished run's row plus its git
+   * run branch and any leftover worktree. A run currently in progress is left
+   * untouched (its row and live worktree are skipped).
+   */
+  async clearRunHistory(repoId: number, jobId: number): Promise<{ cleared: number }> {
+    const repo = this.assertRepo(repoId)
+    this.assertJob(repoId, jobId)
+
+    const removable = listScheduleRunArtifactsByJob(this.db, repoId, jobId).filter((run) => run.status !== 'running')
+    if (removable.length === 0) {
+      return { cleared: 0 }
+    }
+
+    await this.worktreeManager.pruneRunArtifacts(repo, removable)
+    const cleared = deleteScheduleRunsByIds(this.db, repoId, jobId, removable.map((run) => run.id))
+    return { cleared }
+  }
+
+  /**
+   * Deletes a single finished run plus its git run branch and any leftover
+   * worktree. A run in progress must be cancelled first.
+   */
+  async deleteRun(repoId: number, jobId: number, runId: number): Promise<void> {
+    const repo = this.assertRepo(repoId)
+    this.assertJob(repoId, jobId)
+    const run = this.getRun(repoId, jobId, runId)
+
+    if (run.status === 'running') {
+      throw new ScheduleServiceError('Cannot delete a run while it is in progress. Cancel it first.', 409)
+    }
+
+    await this.worktreeManager.pruneRunArtifacts(repo, [{ runBranch: run.runBranch, worktreePath: run.worktreePath }])
+    const deleted = deleteScheduleRunById(this.db, repoId, jobId, runId)
+    if (!deleted) {
+      throw new ScheduleServiceError('Run not found', 404)
+    }
+  }
+
   async runJob(repoId: number, jobId: number, triggerSource: ScheduleRunTriggerSource): Promise<ScheduleRun> {
     const repo = this.assertRepo(repoId)
     const job = this.assertJob(repoId, jobId)