secondshift 0.1.0b12__py3-none-any.whl

secondshift/runs/issue_delivery.py

@@ -0,0 +1,144 @@
+"""Open the issues a finished run's agent proposed.
+
+This reads only what the run stored, so a retry needs no agent or sandbox.
+The token is limited to this repository and to issues. It never reaches the
+sandbox or the model.
+"""
+
+import logging
+
+from secondshift.connections.github import shows_attribution
+from secondshift.connections.models import Connection
+from secondshift.github import credentials
+from secondshift.github.errors import GitHubError
+from secondshift.github.issues import open_issue, open_issue_titled
+from secondshift.repositories.github_access import github_access
+from secondshift.repositories.models import Repository
+from secondshift.runs.dao import (
+    create_delivery,
+    finish_delivery,
+    get_run,
+    has_proposed_issues,
+    opened_issues,
+    run_delivery,
+    unopened_issues,
+)
+from secondshift.runs.execution.issues import issue_labels, issue_limit
+from secondshift.runs.models import Run, RunDelivery, RunIssue
+from secondshift.runs.reporting.collection import plural
+
+logger = logging.getLogger(__name__)
+
+APP_WRITE_HINT = (
+    "GitHub refused to open issues. Give the GitHub App Issues write "
+    "permission, then retry."
+)
+
+
+def record_pending_issues(run: Run) -> None:
+    """Shown as pending from the start, and kept if opening fails."""
+    if issue_limit(run.plan):
+        create_delivery(
+            run, RunDelivery.Kind.ISSUES, f"Issues in {run.repository.full_name}"
+        )
+
+
+def issues_delivery(run: Run) -> RunDelivery | None:
+    return run_delivery(run, RunDelivery.Kind.ISSUES)
+
+
+def skip_reason(run: Run, repository: Repository) -> str:
+    """Why this run opens no issues, or an empty string if it should."""
+    if repository.source_type != Repository.SourceType.GITHUB:
+        return "Local repositories cannot receive issues."
+    if not repository.allow_issues:
+        return "An owner has not allowed issues for this repository."
+    if run.status != Run.Status.SUCCEEDED:
+        return "The run did not succeed."
+    if not has_proposed_issues(run):
+        return "The agent proposed no issues."
+    return ""
+
+
+def issue_body(run: Run, issue: RunIssue) -> str:
+    """The agent's text, and a footer when the connection shows attribution."""
+    if not shows_attribution(run.repository.github_connection):
+        return issue.body
+    footer = f"Opened by SecondShift from run #{run.pk} at {run.commit_sha[:12]}."
+    return f"{issue.body}\n\n---\n\n{footer}" if issue.body else footer
+
+
+def open_run_issues(run_id: int) -> None:
+    run = get_run(
+        run_id,
+        "job__repository__github_connection",
+        "task__repository__github_connection",
+    )
+    delivery = issues_delivery(run)
+    if delivery is None or delivery.status == RunDelivery.Status.DELIVERED:
+        return
+    repository = run.repository
+    if reason := skip_reason(run, repository):
+        finish_delivery(delivery, RunDelivery.Status.SKIPPED, reason)
+        return
+    delivery.attempts += 1
+    try:
+        access = github_access(repository, credentials.ISSUES_WRITE)
+    except GitHubError as error:
+        with_token = (
+            repository.github_connection is not None
+            and repository.github_connection.auth_strategy
+            == Connection.AuthStrategy.API_KEY
+        )
+        # Token errors already say what to fix, such as an expired token.
+        finish_delivery(
+            delivery,
+            RunDelivery.Status.FAILED,
+            str(error) if with_token else APP_WRITE_HINT,
+        )
+        return
+    try:
+        # Issues opened by an earlier attempt keep their number.
+        for issue in unopened_issues(run):
+            found = open_issue_titled(access.token, access.full_name, issue.title)
+            if found is None:
+                found = open_issue(
+                    access.token,
+                    access.full_name,
+                    issue.title,
+                    issue_body(run, issue),
+                    issue_labels(run.plan),
+                )
+            else:
+                issue.already_open = True
+            issue.number, issue.url = found.number, found.url
+            issue.save(update_fields=["number", "url", "already_open"])
+    except GitHubError as error:
+        # These messages never contain the token.
+        finish_delivery(
+            delivery, RunDelivery.Status.FAILED, f"{done(run)}{error}".strip()
+        )
+        return
+    except Exception:
+        logger.exception("opening issues for run %s failed", run_id)
+        finish_delivery(
+            delivery,
+            RunDelivery.Status.FAILED,
+            f"{done(run)}Opening issues failed unexpectedly.".strip(),
+        )
+        return
+    finish_delivery(delivery, RunDelivery.Status.DELIVERED, done(run).strip())
+
+
+def done(run: Run) -> str:
+    """What has happened so far, as a sentence or two followed by a space."""
+    issues = opened_issues(run)
+    opened = sum(1 for issue in issues if not issue.already_open)
+    already = len(issues) - opened
+    parts = []
+    if opened:
+        parts.append(f"Opened {plural(opened, 'issue')}.")
+    if already:
+        verb = "was" if already == 1 else "were"
+        parts.append(f"{plural(already, 'issue')} {verb} already open.")
+    return " ".join(parts) + " " if parts else ""

secondshift/runs/management/commands/prune_runs.py

@@ -0,0 +1,12 @@
+import djclick as click
+
+from secondshift.runs.retention import prune_runs
+
+
+@click.command()
+@click.option(
+    "--days", type=int, default=None, help="Override SECONDSHIFT_RUN_RETENTION_DAYS."
+)
+def command(days: int | None) -> None:
+    """Delete finished runs past retention, with their output and DBOS records."""
+    click.echo(f"Pruned {prune_runs(days)} run(s)")

secondshift/runs/management/commands/run_dbos_worker.py

@@ -0,0 +1,129 @@
+import logging
+import signal
+import threading
+from pathlib import Path
+from types import FrameType
+
+import djclick as click
+from dbos import DBOS, DBOSClient
+from django.conf import settings
+
+from secondshift.connections.agents import retry_credential_cleanups
+from secondshift.jobs.autosync import server_syncs, sync_moved_repositories
+from secondshift.mcp_server.audit import prune_tool_calls
+from secondshift.repositories.github_check import check_due_sources
+from secondshift.repositories.sources import prune_source_cache
+from secondshift.runs.orchestration.dbos_runtime import (
+    launch_dbos_worker,
+    new_dbos_client,
+)
+from secondshift.runs.orchestration.dispatch import dispatch_waiting_tasks
+from secondshift.runs.orchestration.periodic import PeriodicTask
+from secondshift.runs.orchestration.reconciliation import reconcile_terminal_workflows
+from secondshift.runs.orchestration.schedules import synchronize_schedules
+from secondshift.runs.retention import prune_runs
+
+logger = logging.getLogger(__name__)
+
+PRUNE_INTERVAL_SECONDS = 24 * 60 * 60
+# How often to look for GitHub connections due for their daily check.
+SOURCE_CHECK_POLL_SECONDS = 60 * 60
+# How often to ask the runner again to remove logins it kept.
+CREDENTIAL_CLEANUP_SECONDS = 60
+
+
+def remove_cached_logins() -> None:
+    if removed := retry_credential_cleanups():
+        logger.info("removed %s cached agent login(s) from the runner", removed)
+
+
+def worker_tasks(client: DBOSClient) -> list[PeriodicTask]:
+    """What the worker repeats, in the order it runs them on each pass."""
+
+    def reconcile() -> None:
+        if count := reconcile_terminal_workflows(client):
+            logger.warning("reconciled %s run(s) from terminal DBOS workflows", count)
+
+    def schedules() -> None:
+        logger.debug("synchronized %s DBOS schedule(s)", synchronize_schedules(client))
+
+    def prune() -> None:
+        logger.info("pruned %s run(s) past retention", prune_runs(client=client))
+        logger.info("pruned %s MCP tool call(s) past retention", prune_tool_calls())
+        cache = prune_source_cache()
+        logger.info(
+            "pruned %s snapshot(s) and %s mirror(s) from the source cache, %s bytes",
+            cache.snapshots,
+            cache.mirrors,
+            cache.bytes,
+        )
+
+    def repositories() -> None:
+        if synced := sync_moved_repositories():
+            logger.info("synced %s repository(s) with new commits", synced)
+
+    def sources() -> None:
+        if checked := check_due_sources():
+            logger.info("checked %s GitHub connection(s)", checked)
+
+    return [
+        PeriodicTask("reconcile runs", every=0, run=reconcile),
+        PeriodicTask("dispatch waiting tasks", every=0, run=dispatch_waiting_tasks),
+        PeriodicTask("sync schedules", every=0, run=schedules),
+        PeriodicTask("prune runs", every=PRUNE_INTERVAL_SECONDS, run=prune),
+        PeriodicTask(
+            "sync repositories",
+            every=settings.REPOSITORY_SYNC_INTERVAL_SECONDS,
+            run=repositories,
+            enabled=server_syncs,
+        ),
+        PeriodicTask(
+            "check GitHub connections",
+            every=SOURCE_CHECK_POLL_SECONDS,
+            run=sources,
+        ),
+        PeriodicTask(
+            "remove cached agent logins",
+            every=CREDENTIAL_CLEANUP_SECONDS,
+            run=remove_cached_logins,
+        ),
+    ]
+
+
+@click.command()
+@click.option("--sync-interval", type=int, default=15, show_default=True)
+@click.option("--ready-file", type=click.Path(path_type=Path), hidden=True)
+def command(sync_interval: int, ready_file: Path | None) -> None:
+    """Run DBOS workers and reconcile database-backed schedules."""
+    stopped = threading.Event()
+
+    def stop(signum: int, frame: FrameType | None) -> None:
+        stopped.set()
+
+    previous = signal.signal(signal.SIGTERM, stop)
+    client = None
+    try:
+        launch_dbos_worker()
+        click.echo("DBOS worker started")
+        client = new_dbos_client()
+        tasks = worker_tasks(client)
+        if ready_file is not None:
+            ready_file.touch(mode=0o600)
+        while not stopped.is_set():
+            for task in tasks:
+                if stopped.is_set():
+                    break
+                task.run_if_due()
+            if stopped.wait(sync_interval):
+                break
+    except KeyboardInterrupt:
+        click.echo("Stopping DBOS worker")
+    finally:
+        try:
+            if client is not None:
+                client.destroy()
+        finally:
+            try:
+                DBOS.destroy(workflow_completion_timeout_sec=10)
+            finally:
+                signal.signal(signal.SIGTERM, previous)

secondshift/runs/migration_helpers.py

@@ -0,0 +1,313 @@
+"""Versioned data operations used by generated runs migrations.
+
+Keep these functions independent of current models and job configuration.
+"""
+
+from typing import Any
+
+from django.apps.registry import Apps
+from django.conf import settings
+from django.db.backends.base.schema import BaseDatabaseSchemaEditor
+
+
+def check_constraints_now_v1(schema_editor: BaseDatabaseSchemaEditor) -> None:
+    """Run the foreign key checks that row changes left for commit.
+
+    A squashed migration runs these steps in one transaction. PostgreSQL
+    refuses to alter a table while those checks are still pending.
+    """
+    if schema_editor.connection.vendor == "postgresql":
+        schema_editor.execute("SET CONSTRAINTS ALL IMMEDIATE")
+
+
+def backfill_tasks_v1(apps: Apps, schema_editor: BaseDatabaseSchemaEditor) -> None:
+    """Preserve the assignment actually recorded on each historical run."""
+    run_model = apps.get_model("runs", "Run")
+    task_model = apps.get_model("runs", "Task")
+    alias = schema_editor.connection.alias
+    while runs := list(
+        run_model.objects.using(alias).filter(task__isnull=True).order_by("pk")[:500]
+    ):
+        tasks = task_model.objects.using(alias).bulk_create(
+            [
+                task_model(
+                    job_id=run.job_id,
+                    origin=run.started_by,
+                    commit_sha=run.commit_sha,
+                    input_snapshot=run.input_snapshot,
+                    scheduled_for=run.scheduled_for,
+                    created_at=run.created_at,
+                )
+                for run in runs
+            ]
+        )
+        for run, task in zip(runs, tasks, strict=True):
+            run.task_id = task.pk
+        run_model.objects.using(alias).bulk_update(runs, ["task"])
+
+
+def backfill_agent_connections_v1(
+    apps: Apps, schema_editor: BaseDatabaseSchemaEditor
+) -> None:
+    """Record the agent login each ready plan chose, so its cap counts it."""
+    run_model = apps.get_model("runs", "Run")
+    login_model = apps.get_model("connections", "AgentConnection")
+    alias = schema_editor.connection.alias
+    logins = set(login_model.objects.using(alias).values_list("pk", flat=True))
+    runs = run_model.objects.using(alias).filter(
+        execution_plan__ready=True,
+        execution_plan__execution__connection_id__isnull=False,
+    )
+    changed = []
+    for run in runs.iterator():
+        login = run.execution_plan["execution"]["connection_id"]
+        if login in logins:
+            run.agent_connection_id = login
+            changed.append(run)
+    run_model.objects.using(alias).bulk_update(changed, ["agent_connection"], 500)
+    check_constraints_now_v1(schema_editor)
+
+
+PLAN_LIMIT_SETTINGS_V1 = {
+    "max_turns": "AGENT_MAX_TURNS",
+    "max_tool_calls": "AGENT_MAX_TOOL_CALLS",
+    "max_tool_result_chars": "AGENT_MAX_TOOL_RESULT_CHARS",
+    "token_budget": "MODEL_RUN_TOKEN_BUDGET",
+    "timeout_seconds": "RUN_TIMEOUT_SECONDS",
+}
+
+
+def picked_v1(values: Any, defaults: dict[str, Any]) -> dict[str, Any]:
+    """The known keys of a stored block, with defaults for missing ones."""
+    values = values if isinstance(values, dict) else {}
+    return {key: values.get(key, default) for key, default in defaults.items()}
+
+
+def normalized_plan_v1(
+    plan: dict[str, Any], fallback: dict[str, Any]
+) -> dict[str, Any]:
+    """One stored plan in the shape every reader now expects.
+
+    Plans from older releases lack blocks added later. A run created without
+    a plan keeps it as not ready, with its job and commit from the run.
+    """
+    agent = plan.get("agent") or {}
+    limits = agent.get("limits") or {}
+    model = plan.get("model")
+    return {
+        "execution": picked_v1(
+            plan.get("execution"),
+            {
+                "backend": "pydantic",
+                "label": "",
+                "ready": True,
+                "problem": "",
+                "connection_id": None,
+                "credential_key": None,
+                "owner_id": None,
+            },
+        ),
+        "ready": bool(plan.get("ready", False)),
+        "agent": {
+            "limits": {
+                key: int(limits.get(key, getattr(settings, name)))
+                for key, name in PLAN_LIMIT_SETTINGS_V1.items()
+            },
+            "tools": list(agent.get("tools") or []),
+            "subagents": int(agent.get("subagents") or 0),
+        },
+        "job": picked_v1(
+            plan.get("job") or fallback["job"],
+            {"key": "", "skill_path": "", "config_hash": ""},
+        ),
+        "repository": picked_v1(
+            plan.get("repository") or fallback["repository"],
+            {"full_name": "", "config_sha": ""},
+        ),
+        "runner": picked_v1(
+            plan.get("runner"),
+            {
+                "image": settings.RUNNER_IMAGE,
+                "network_policy": "none",
+                "collect_changes": False,
+            },
+        ),
+        "pull_request": (
+            picked_v1(plan["pull_request"], {"base": "", "run_ci": False})
+            if plan.get("pull_request")
+            else None
+        ),
+        "issues": (
+            picked_v1(plan["issues"], {"max": 0, "labels": []})
+            if plan.get("issues")
+            else None
+        ),
+        "model": (
+            picked_v1(
+                model,
+                {
+                    "connection_id": 0,
+                    "connection_name": "",
+                    "provider": "",
+                    "family": "",
+                    "default_model": "",
+                    "allowed_models": [],
+                },
+            )
+            if isinstance(model, dict)
+            else None
+        ),
+        "capabilities": [
+            picked_v1(
+                capability,
+                {
+                    "binding": "",
+                    "kind": "",
+                    "required": True,
+                    "requested_tools": [],
+                    "connection_id": None,
+                    "connection_name": None,
+                    "effective_tools": [],
+                    "authorized": False,
+                    "reasons": [],
+                    "missing": None,
+                    "external": None,
+                    "tool_rules": {},
+                },
+            )
+            for capability in plan.get("capabilities") or []
+        ],
+    }
+
+
+def normalize_execution_plans_v1(
+    apps: Apps, schema_editor: BaseDatabaseSchemaEditor
+) -> None:
+    """Rewrite every stored plan in the current shape."""
+    run_model = apps.get_model("runs", "Run")
+    alias = schema_editor.connection.alias
+    runs = run_model.objects.using(alias).select_related(
+        "job__repository", "task__repository"
+    )
+    changed = []
+    for run in runs.iterator(chunk_size=500):
+        job = run.job
+        repository = job.repository if job else run.task.repository
+        fallback = {
+            "job": {
+                "key": job.key if job else "",
+                "skill_path": job.skill_path if job else "",
+                "config_hash": job.config_hash if job else "",
+            },
+            "repository": {
+                "full_name": repository.full_name if repository else "",
+                "config_sha": run.commit_sha,
+            },
+        }
+        normalized = normalized_plan_v1(run.execution_plan or {}, fallback)
+        if normalized != run.execution_plan:
+            run.execution_plan = normalized
+            changed.append(run)
+    run_model.objects.using(alias).bulk_update(changed, ["execution_plan"], 500)
+    check_constraints_now_v1(schema_editor)
+
+
+def record_run_starts_v1(apps: Apps, schema_editor: BaseDatabaseSchemaEditor) -> None:
+    """Keep what started each run on the run, before tasks drop their origin.
+
+    MCP starts were recorded as manual runs with an MCP task. Runs from
+    before starts were recorded count as scheduled.
+    """
+    run_model = apps.get_model("runs", "Run")
+    alias = schema_editor.connection.alias
+    runs = run_model.objects.using(alias)
+    runs.filter(task__origin="mcp").update(started_by="mcp")
+    runs.filter(started_by="").update(started_by="schedule")
+    check_constraints_now_v1(schema_editor)
+
+
+def assign_task_repositories_v1(
+    apps: Apps, schema_editor: BaseDatabaseSchemaEditor
+) -> None:
+    """Give every run a task, and every task its repository and fingerprint."""
+    run_model = apps.get_model("runs", "Run")
+    task_model = apps.get_model("runs", "Task")
+    alias = schema_editor.connection.alias
+    for run in (
+        run_model.objects.using(alias)
+        .filter(task__isnull=True)
+        .select_related("job")
+        .iterator()
+    ):
+        run.task = task_model.objects.using(alias).create(
+            job_id=run.job_id,
+            repository_id=run.job.repository_id,
+            commit_sha=run.commit_sha,
+            scheduled_for=run.scheduled_for,
+            created_at=run.created_at,
+        )
+        run.save(update_fields=["task"])
+    tasks = task_model.objects.using(alias).select_related("job")
+    changed = []
+    for task in tasks.iterator():
+        if task.repository_id is None:
+            task.repository_id = task.job.repository_id
+        task.fingerprint = str(task.input_snapshot.get("submission_fingerprint", ""))
+        changed.append(task)
+    task_model.objects.using(alias).bulk_update(
+        changed, ["repository", "fingerprint"], 500
+    )
+    check_constraints_now_v1(schema_editor)
+
+
+# The summaries v0.1.0b10 wrote, by the failure each one names.
+FAILURE_HEADLINES_V1 = {
+    "Timed out": "timeout",
+    "Budget used up": "budget",
+    "The run could not start": "starting",
+    "Couldn't check out the repository": "checkout",
+    "Couldn't start the sandbox": "sandbox",
+    "The skill run failed": "skill",
+    "The run could not be recorded": "finishing",
+}
+STAGES_V1 = {"starting", "checkout", "sandbox", "skill", "finishing"}
+ENQUEUE_FAILED_V1 = "The durable workflow could not be enqueued."
+MODEL_PROVIDER_PREFIX_V1 = "The model provider answered "
+TOOL_RULE_PREFIX_V1 = "Blocked by a tool restriction: "
+WORKFLOW_PREFIX_V1 = "The durable workflow failed unexpectedly ("
+
+
+def failure_from_summary_v1(summary: str) -> tuple[str, str]:
+    """The failure kind and reason an older failed run's summary names."""
+    if summary == ENQUEUE_FAILED_V1:
+        return "not_queued", summary
+    text = " ".join(summary.split())
+    if text.startswith(WORKFLOW_PREFIX_V1) and text.endswith(")."):
+        return "other", f"Unexpected {text[len(WORKFLOW_PREFIX_V1) : -2]}."
+    for headline, kind in FAILURE_HEADLINES_V1.items():
+        if not text.startswith(f"{headline}: "):
+            continue
+        detail = text[len(headline) + 2 :]
+        if kind in STAGES_V1 and detail.startswith(MODEL_PROVIDER_PREFIX_V1):
+            reason = detail.removeprefix(MODEL_PROVIDER_PREFIX_V1)
+            return "model_provider", reason.replace(": ", " · ", 1)
+        if kind in STAGES_V1 and detail.startswith(TOOL_RULE_PREFIX_V1):
+            return "tool_rule", detail.removeprefix(TOOL_RULE_PREFIX_V1)
+        return kind, detail
+    return "other", summary
+
+
+def record_run_failures_v1(apps: Apps, schema_editor: BaseDatabaseSchemaEditor) -> None:
+    """Record why each earlier failed run failed, from its summary."""
+    run_model = apps.get_model("runs", "Run")
+    runs = run_model.objects.using(schema_editor.connection.alias).filter(
+        status="failed", failure=""
+    )
+    changed = []
+    for run in runs.only("pk", "summary").iterator():
+        run.failure, run.failure_reason = failure_from_summary_v1(run.summary)
+        changed.append(run)
+    run_model.objects.using(schema_editor.connection.alias).bulk_update(
+        changed, ["failure", "failure_reason"], 500
+    )
+    check_constraints_now_v1(schema_editor)

secondshift/runs/migrations/0001_initial.py

@@ -0,0 +1,69 @@
+# Generated by Django 6.0.9 on 2026-10-26 14:22
+
+import django.db.models.deletion
+import uuid
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    initial = True
+
+    dependencies = [
+        ('jobs', '0001_initial'),
+    ]
+
+    operations = [
+        migrations.CreateModel(
+            name='Run',
+            fields=[
+                ('id', models.BigAutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
+                ('status', models.CharField(choices=[('queued', 'Queued'), ('running', 'Running'), ('succeeded', 'Succeeded'), ('failed', 'Failed'), ('canceled', 'Canceled')], default='queued', max_length=16)),
+                ('commit_sha', models.CharField(max_length=64)),
+                ('scheduled_for', models.DateTimeField()),
+                ('started_at', models.DateTimeField(blank=True, null=True)),
+                ('finished_at', models.DateTimeField(blank=True, null=True)),
+                ('sandbox_runtime', models.CharField(blank=True, max_length=32)),
+                ('exit_code', models.IntegerField(blank=True, null=True)),
+                ('summary', models.TextField(blank=True)),
+                ('input_snapshot', models.JSONField(blank=True, default=dict)),
+                ('execution_plan', models.JSONField(blank=True, default=dict)),
+                ('output_excerpt', models.TextField(blank=True)),
+                ('input_path', models.CharField(blank=True, max_length=500)),
+                ('input_size_bytes', models.BigIntegerField(blank=True, null=True)),
+                ('output_path', models.CharField(blank=True, max_length=500)),
+                ('output_size_bytes', models.BigIntegerField(blank=True, null=True)),
+                ('output_sha256', models.CharField(blank=True, max_length=64)),
+                ('output_truncated', models.BooleanField(default=False)),
+                ('dbos_workflow_id', models.CharField(blank=True, db_index=True, max_length=200)),
+                ('runner_session_key', models.UUIDField(default=uuid.uuid4, editable=False)),
+                ('created_at', models.DateTimeField(auto_now_add=True)),
+                ('job', models.ForeignKey(on_delete=django.db.models.deletion.PROTECT, related_name='runs', to='jobs.job')),
+            ],
+            options={
+                'ordering': ['-created_at'],
+            },
+        ),
+        migrations.CreateModel(
+            name='RunEvent',
+            fields=[
+                ('id', models.BigAutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
+                ('level', models.CharField(default='info', max_length=16)),
+                ('message', models.TextField()),
+                ('metadata', models.JSONField(blank=True, default=dict)),
+                ('created_at', models.DateTimeField(auto_now_add=True)),
+                ('run', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, related_name='events', to='runs.run')),
+            ],
+            options={
+                'ordering': ['created_at'],
+            },
+        ),
+        migrations.AddIndex(
+            model_name='run',
+            index=models.Index(fields=['status', 'created_at'], name='runs_status_created_at_idx'),
+        ),
+        migrations.AddConstraint(
+            model_name='run',
+            constraint=models.UniqueConstraint(fields=('job', 'scheduled_for'), name='unique_job_scheduled_run'),
+        ),
+    ]