Function persistAutonomyRunRecord

src/utils/autonomyRuns.ts:397–456

(
  record: AutonomyRunRecord,
  rootDir: string,
  skipWhenActiveSource: boolean,
)

}

async function persistAutonomyRunRecord(
  record: AutonomyRunRecord,
  rootDir: string,
  skipWhenActiveSource: boolean,
): Promise<{
  created: boolean
  recoveredStaleRuns: AutonomyRunRecord[]
}> {
  let created = false
  const recoveredStaleRuns: AutonomyRunRecord[] = []
  await withAutonomyPersistenceLock(rootDir, async () => {
    const runs = await listAutonomyRuns(rootDir)
    const sourceId = record.sourceId
    if (skipWhenActiveSource && sourceId) {
      let hasBlockingActiveRun = false
      let staleRecoveriesApplied = false
      for (let i = 0; i < runs.length; i++) {
        const run = runs[i]!
        if (
          !matchesActiveAutonomyRunSource(run, {
            trigger: record.trigger,
            sourceId,
            ownerKey: record.ownerKey,
          })
        ) {
          continue
        }
        if (isStaleActiveAutonomyRun(run)) {
          const recovered = recoverStaleActiveAutonomyRun(run, record.createdAt)
          runs[i] = recovered
          recoveredStaleRuns.push(recovered)
          staleRecoveriesApplied = true
          continue
        }
        if (
          run.ownerProcessId === undefined &&
          !warnedLegacyBlockRunIds.has(run.runId)
        ) {
          warnedLegacyBlockRunIds.add(run.runId)
          logError(
            new Error(
              `[autonomyRuns] blocked by legacy un-owned active run ${run.runId} (createdAt=${run.createdAt}); cancel manually if this is a stale upgrade artifact`,
            ),
          )
        }
        hasBlockingActiveRun = true
      }
      if (hasBlockingActiveRun) {
        if (staleRecoveriesApplied) {
          await writeAutonomyRuns(runs, rootDir)
        }
        return
      }
    }
    runs.unshift(record)
    await writeAutonomyRuns(runs, rootDir)
    created = true
  })