@innofeight/global-workflow 0.0.1 → 0.0.2

package/scripts/lib/aet-v2.mjs

@@ -0,0 +1,673 @@
+const SCHEMA = 'rn-launcher/aet-v2-event/v1'
+const METRIC = 'AET-v2'
+
+const EVENT_TYPES = new Set([
+  'AET_V2_LEDGER_DECLARED',
+  'AET_V2_SEGMENT_STARTED',
+  'AET_V2_SEGMENT_ENDED',
+  'AET_V2_ESTIMATE_REVISED',
+  'AET_V2_NON_AET_RECORDED',
+  'AET_V2_MILESTONE_RECORDED',
+  'AET_V2_CORRECTION_RECORDED'
+])
+
+const NON_AET_CLOCKS = new Set([
+  'human-attention',
+  'human-qa',
+  'human-unavailable',
+  'human-wait',
+  'external-system-wait'
+])
+
+const YIELD_CLOCKS = new Set(['human-wait', 'external-system-wait'])
+const EXCLUSIVE_COVERAGE_CLOCKS = YIELD_CLOCKS
+
+const COMMON_KEYS = [
+  'eventId',
+  'eventType',
+  'metric',
+  'recordedAt',
+  'schema',
+  'source'
+]
+
+const EVENT_KEYS = {
+  AET_V2_CORRECTION_RECORDED: ['reason', 'replacement', 'targetEventId'],
+  AET_V2_ESTIMATE_REVISED: [
+    'approvalSource',
+    'reason',
+    'revisedTotalEstimateMinutes',
+    'scopeDeltaMinutes',
+    'taskId',
+    'timestamp'
+  ],
+  AET_V2_LEDGER_DECLARED: [
+    'calendarStartedAt',
+    'originalEstimateMinutes',
+    'taskId',
+    'taskTitle',
+    'workClass'
+  ],
+  AET_V2_MILESTONE_RECORDED: ['evidence', 'milestone', 'taskId', 'timestamp'],
+  AET_V2_NON_AET_RECORDED: [
+    'clock',
+    'endedAt',
+    'evidence',
+    'startedAt',
+    'taskId'
+  ],
+  AET_V2_SEGMENT_ENDED: [
+    'endReason',
+    'executionId',
+    'startEventId',
+    'taskId',
+    'timestamp'
+  ],
+  AET_V2_SEGMENT_STARTED: [
+    'category',
+    'executionId',
+    'reason',
+    'taskId',
+    'timestamp'
+  ]
+}
+
+function fail(code, detail) {
+  throw new Error(`${code}: ${detail}`)
+}
+
+function record(value, label) {
+  if (!value || typeof value !== 'object' || Array.isArray(value))
+    fail('aet-v2.invalid-record', `${label} must be an object`)
+  return value
+}
+
+function text(value, label) {
+  if (typeof value !== 'string' || !value.trim())
+    fail('aet-v2.invalid-field', `${label} must be a non-empty string`)
+  return value
+}
+
+function instant(value, label) {
+  const source = text(value, label)
+  const milliseconds = Date.parse(source)
+  if (
+    !Number.isFinite(milliseconds) ||
+    new Date(milliseconds).toISOString() !== source
+  )
+    fail('aet-v2.invalid-timestamp', `${label} must be canonical UTC ISO-8601`)
+  return milliseconds
+}
+
+function positiveNumber(value, label) {
+  if (typeof value !== 'number' || !Number.isFinite(value) || value <= 0)
+    fail('aet-v2.invalid-field', `${label} must be a positive number`)
+  return value
+}
+
+function common(event) {
+  record(event, 'event')
+  if (event.schema !== SCHEMA)
+    fail('aet-v2.unsupported-schema', String(event.schema ?? 'missing'))
+  if (event.metric !== METRIC)
+    fail('aet-v2.metric-regime-mismatch', String(event.metric ?? 'missing'))
+  text(event.eventId, 'eventId')
+  if (!EVENT_TYPES.has(event.eventType))
+    fail('aet-v2.unsupported-event', String(event.eventType ?? 'missing'))
+  const allowed = new Set([...COMMON_KEYS, ...EVENT_KEYS[event.eventType]])
+  const unknown = Object.keys(event).find((key) => !allowed.has(key))
+  if (unknown) fail('aet-v2.unknown-field', `${event.eventType}.${unknown}`)
+  instant(event.recordedAt, 'recordedAt')
+  text(event.source, 'source')
+}
+
+export function validateAetV2Event(event) {
+  common(event)
+  switch (event.eventType) {
+    case 'AET_V2_LEDGER_DECLARED':
+      text(event.taskId, 'taskId')
+      text(event.taskTitle, 'taskTitle')
+      text(event.workClass, 'workClass')
+      positiveNumber(event.originalEstimateMinutes, 'originalEstimateMinutes')
+      instant(event.calendarStartedAt, 'calendarStartedAt')
+      break
+    case 'AET_V2_SEGMENT_STARTED':
+      text(event.taskId, 'taskId')
+      text(event.executionId, 'executionId')
+      instant(event.timestamp, 'timestamp')
+      text(event.category, 'category')
+      text(event.reason, 'reason')
+      break
+    case 'AET_V2_SEGMENT_ENDED':
+      text(event.taskId, 'taskId')
+      text(event.executionId, 'executionId')
+      instant(event.timestamp, 'timestamp')
+      text(event.startEventId, 'startEventId')
+      text(event.endReason, 'endReason')
+      break
+    case 'AET_V2_ESTIMATE_REVISED':
+      text(event.taskId, 'taskId')
+      instant(event.timestamp, 'timestamp')
+      positiveNumber(
+        event.revisedTotalEstimateMinutes,
+        'revisedTotalEstimateMinutes'
+      )
+      if (
+        typeof event.scopeDeltaMinutes !== 'number' ||
+        !Number.isFinite(event.scopeDeltaMinutes)
+      )
+        fail(
+          'aet-v2.invalid-field',
+          'scopeDeltaMinutes must be a finite number'
+        )
+      text(event.reason, 'reason')
+      text(event.approvalSource, 'approvalSource')
+      break
+    case 'AET_V2_NON_AET_RECORDED':
+      text(event.taskId, 'taskId')
+      if (!NON_AET_CLOCKS.has(event.clock))
+        fail('aet-v2.invalid-clock', String(event.clock ?? 'missing'))
+      instant(event.startedAt, 'startedAt')
+      instant(event.endedAt, 'endedAt')
+      if (Date.parse(event.endedAt) <= Date.parse(event.startedAt))
+        fail('aet-v2.invalid-interval', event.eventId)
+      text(event.evidence, 'evidence')
+      break
+    case 'AET_V2_MILESTONE_RECORDED':
+      text(event.taskId, 'taskId')
+      if (!['first-pr-ready', 'merged', 'complete'].includes(event.milestone))
+        fail('aet-v2.invalid-milestone', String(event.milestone ?? 'missing'))
+      instant(event.timestamp, 'timestamp')
+      text(event.evidence, 'evidence')
+      break
+    case 'AET_V2_CORRECTION_RECORDED': {
+      text(event.targetEventId, 'targetEventId')
+      text(event.reason, 'reason')
+      const replacement = record(event.replacement, 'replacement')
+      common(replacement)
+      if (replacement.eventId !== event.targetEventId)
+        fail(
+          'aet-v2.invalid-correction',
+          'replacement must retain target eventId'
+        )
+      if (replacement.eventType === 'AET_V2_CORRECTION_RECORDED')
+        fail(
+          'aet-v2.invalid-correction',
+          'correction events cannot replace corrections'
+        )
+      validateAetV2Event(replacement)
+      break
+    }
+  }
+  return event
+}
+
+export function parseAetV2JsonLines(contents) {
+  if (typeof contents !== 'string')
+    fail('aet-v2.invalid-ledger', 'ledger must be text')
+  const events = contents
+    .split(/\r?\n/u)
+    .map((line) => line.trim())
+    .filter(Boolean)
+    .map((line, index) => {
+      try {
+        return JSON.parse(line)
+      } catch {
+        fail('aet-v2.invalid-json', `line ${index + 1}`)
+      }
+    })
+  if (!events.length) fail('aet-v2.empty-ledger', 'no events')
+  return events
+}
+
+function correctedEvents(events) {
+  const semantic = new Map()
+  const sourceEventIds = new Set()
+  const order = []
+  const corrected = new Set()
+  const correctionTaskIds = []
+  for (const event of events) {
+    validateAetV2Event(event)
+    if (sourceEventIds.has(event.eventId))
+      fail('aet-v2.duplicate-event-id', event.eventId)
+    sourceEventIds.add(event.eventId)
+    if (event.eventType === 'AET_V2_CORRECTION_RECORDED') {
+      if (!semantic.has(event.targetEventId))
+        fail('aet-v2.correction-target-missing', event.targetEventId)
+      const target = semantic.get(event.targetEventId)
+      if (target.eventType === 'AET_V2_LEDGER_DECLARED')
+        fail('aet-v2.immutable-original-estimate', event.targetEventId)
+      if (event.replacement.eventType !== target.eventType)
+        fail(
+          'aet-v2.correction-type-mismatch',
+          `${event.targetEventId} must remain ${target.eventType}`
+        )
+      if (event.replacement.taskId !== target.taskId)
+        fail(
+          'aet-v2.correction-task-mismatch',
+          `${event.targetEventId} must remain on ${target.taskId}`
+        )
+      if (corrected.has(event.targetEventId))
+        fail('aet-v2.correction-duplicate', event.targetEventId)
+      semantic.set(event.targetEventId, event.replacement)
+      corrected.add(event.targetEventId)
+      correctionTaskIds.push(event.replacement.taskId)
+      continue
+    }
+    semantic.set(event.eventId, event)
+    order.push(event.eventId)
+  }
+  return {
+    events: order.map((id) => semantic.get(id)),
+    correctionTaskIds,
+    corrections: corrected.size
+  }
+}
+
+function overlaps(left, right) {
+  return left.start < right.end && right.start < left.end
+}
+
+export function analyzeAetV2Ledger(input, options = {}) {
+  const sourceEvents = Array.isArray(input) ? input : parseAetV2JsonLines(input)
+  const corrected = correctedEvents(sourceEvents)
+  const declarations = new Map()
+  const starts = new Map()
+  const ends = new Map()
+  const nonAet = []
+  const milestones = []
+  const estimateRevisions = []
+
+  for (const event of corrected.events) {
+    if (event.eventType === 'AET_V2_LEDGER_DECLARED') {
+      if (declarations.has(event.taskId))
+        fail('aet-v2.duplicate-declaration', event.taskId)
+      declarations.set(event.taskId, event)
+    } else if (event.eventType === 'AET_V2_SEGMENT_STARTED') {
+      starts.set(event.eventId, event)
+    } else if (event.eventType === 'AET_V2_SEGMENT_ENDED') {
+      if (ends.has(event.startEventId))
+        fail('aet-v2.duplicate-end', event.startEventId)
+      ends.set(event.startEventId, event)
+    } else if (event.eventType === 'AET_V2_ESTIMATE_REVISED') {
+      estimateRevisions.push(event)
+    } else if (event.eventType === 'AET_V2_NON_AET_RECORDED') nonAet.push(event)
+    else if (event.eventType === 'AET_V2_MILESTONE_RECORDED')
+      milestones.push(event)
+  }
+
+  if (!declarations.size)
+    fail('aet-v2.missing-declaration', 'no task ledger declaration')
+  const intervals = []
+  for (const [startId, end] of ends) {
+    const start = starts.get(startId)
+    if (!start) fail('aet-v2.missing-start', startId)
+    if (start.taskId !== end.taskId || start.executionId !== end.executionId)
+      fail('aet-v2.segment-identity-mismatch', startId)
+    const startMs = instant(start.timestamp, 'timestamp')
+    const endMs = instant(end.timestamp, 'timestamp')
+    if (endMs <= startMs) fail('aet-v2.invalid-interval', startId)
+    intervals.push({
+      category: start.category,
+      end: endMs,
+      executionId: start.executionId,
+      start: startMs,
+      startEventId: startId,
+      taskId: start.taskId
+    })
+  }
+  const openStarts = [...starts.entries()].filter(
+    ([startId]) => !ends.has(startId)
+  )
+  if (!options.allowIncomplete && openStarts.length)
+    fail('aet-v2.missing-end', openStarts[0][0])
+  if (options.allowIncomplete && openStarts.length > 1)
+    fail(
+      'aet-v2.contradictory-open-segments',
+      openStarts.map(([startId]) => startId).join(',')
+    )
+
+  intervals.sort(
+    (left, right) => left.start - right.start || left.end - right.end
+  )
+  for (let index = 1; index < intervals.length; index += 1)
+    if (overlaps(intervals[index - 1], intervals[index]))
+      fail(
+        'aet-v2.overlapping-agent-segments',
+        `${intervals[index - 1].startEventId} overlaps ${intervals[index].startEventId}`
+      )
+
+  for (const wait of nonAet) {
+    if (!EXCLUSIVE_COVERAGE_CLOCKS.has(wait.clock)) continue
+    const waitInterval = {
+      start: Date.parse(wait.startedAt),
+      end: Date.parse(wait.endedAt)
+    }
+    const conflict = intervals.find(
+      (interval) =>
+        interval.taskId === wait.taskId && overlaps(interval, waitInterval)
+    )
+    if (conflict)
+      fail(
+        'aet-v2.yield-overlaps-agent-segment',
+        `${wait.eventId} overlaps ${conflict.startEventId}`
+      )
+  }
+
+  const exclusiveCoverage = nonAet
+    .filter((event) => EXCLUSIVE_COVERAGE_CLOCKS.has(event.clock))
+    .map((event) => ({
+      end: Date.parse(event.endedAt),
+      eventId: event.eventId,
+      start: Date.parse(event.startedAt),
+      taskId: event.taskId
+    }))
+    .sort((left, right) => left.start - right.start || left.end - right.end)
+  for (const taskId of new Set(exclusiveCoverage.map((item) => item.taskId))) {
+    const taskCoverage = exclusiveCoverage.filter(
+      (item) => item.taskId === taskId
+    )
+    for (let index = 1; index < taskCoverage.length; index += 1) {
+      const previous = taskCoverage[index - 1]
+      const current = taskCoverage[index]
+      if (overlaps(previous, current))
+        fail(
+          'aet-v2.overlapping-exclusive-coverage',
+          `${previous.eventId} overlaps ${current.eventId}`
+        )
+    }
+  }
+
+  for (const taskId of new Set(nonAet.map((item) => item.taskId))) {
+    const taskClocks = nonAet.filter((item) => item.taskId === taskId)
+    for (const clock of new Set(taskClocks.map((item) => item.clock))) {
+      const clockIntervals = taskClocks
+        .filter((item) => item.clock === clock)
+        .map((item) => ({
+          end: Date.parse(item.endedAt),
+          eventId: item.eventId,
+          start: Date.parse(item.startedAt)
+        }))
+        .sort((left, right) => left.start - right.start || left.end - right.end)
+      for (let index = 1; index < clockIntervals.length; index += 1)
+        if (overlaps(clockIntervals[index - 1], clockIntervals[index]))
+          fail(
+            'aet-v2.overlapping-clock-intervals',
+            `${clockIntervals[index - 1].eventId} overlaps ${clockIntervals[index].eventId}`
+          )
+    }
+  }
+
+  const tasks = {}
+  for (const [taskId, declaration] of declarations) {
+    const taskIntervals = intervals.filter(
+      (interval) => interval.taskId === taskId
+    )
+    const categoryMilliseconds = {}
+    for (const interval of taskIntervals)
+      categoryMilliseconds[interval.category] =
+        (categoryMilliseconds[interval.category] ?? 0) +
+        interval.end -
+        interval.start
+    const aetMilliseconds = taskIntervals.reduce(
+      (total, interval) => total + interval.end - interval.start,
+      0
+    )
+    const clockMilliseconds = {}
+    for (const item of nonAet.filter((event) => event.taskId === taskId))
+      clockMilliseconds[item.clock] =
+        (clockMilliseconds[item.clock] ?? 0) +
+        Date.parse(item.endedAt) -
+        Date.parse(item.startedAt)
+    const taskMilestones = milestones.filter((event) => event.taskId === taskId)
+    const taskEstimateRevisions = estimateRevisions
+      .filter((event) => event.taskId === taskId)
+      .sort(
+        (left, right) =>
+          Date.parse(left.timestamp) - Date.parse(right.timestamp) ||
+          left.eventId.localeCompare(right.eventId)
+      )
+    const latestEvidenceAt = Math.max(
+      Date.parse(declaration.calendarStartedAt),
+      ...taskIntervals.map((interval) => interval.end),
+      ...nonAet
+        .filter((event) => event.taskId === taskId)
+        .map((event) => Date.parse(event.endedAt)),
+      ...taskMilestones.map((event) => Date.parse(event.timestamp)),
+      ...taskEstimateRevisions.map((event) => Date.parse(event.timestamp))
+    )
+    const milestonesNamed = (name) =>
+      taskMilestones
+        .filter((event) => event.milestone === name)
+        .sort(
+          (left, right) =>
+            Date.parse(left.timestamp) - Date.parse(right.timestamp) ||
+            left.eventId.localeCompare(right.eventId)
+        )
+    const merges = milestonesNamed('merged')
+    const completions = milestonesNamed('complete')
+    const firstPrReadies = milestonesNamed('first-pr-ready')
+    const merged = merges.at(-1)
+    const complete = completions.at(-1)
+    if (options.postMerge && (!merged || !complete))
+      fail(
+        'aet-v2.post-merge-incomplete',
+        `${taskId} requires merged and complete milestones`
+      )
+    if (complete && !merged)
+      fail('aet-v2.invalid-milestone-order', `${taskId} complete without merge`)
+    if (
+      complete &&
+      merged &&
+      Date.parse(complete.timestamp) < Date.parse(merged.timestamp)
+    )
+      fail(
+        'aet-v2.invalid-milestone-order',
+        `${taskId} completion precedes latest merge`
+      )
+    const firstPrReady = firstPrReadies[0]
+    if (
+      firstPrReadies.some(
+        (event) =>
+          merged &&
+          Date.parse(event.timestamp) > Date.parse(merges[0].timestamp)
+      )
+    )
+      fail(
+        'aet-v2.invalid-milestone-order',
+        `${taskId} first PR-ready follows merge`
+      )
+    const latestEstimateRevision = taskEstimateRevisions.at(-1)
+    let approvedEstimateMinutes = declaration.originalEstimateMinutes
+    for (const revision of taskEstimateRevisions) {
+      if (
+        Math.abs(
+          approvedEstimateMinutes +
+            revision.scopeDeltaMinutes -
+            revision.revisedTotalEstimateMinutes
+        ) > Number.EPSILON
+      )
+        fail(
+          'aet-v2.inconsistent-estimate-revision',
+          `${revision.eventId} delta does not reconcile`
+        )
+      approvedEstimateMinutes = revision.revisedTotalEstimateMinutes
+    }
+    const latestApprovedEstimateMinutes =
+      latestEstimateRevision?.revisedTotalEstimateMinutes ??
+      declaration.originalEstimateMinutes
+    const calendarStartedAt = Date.parse(declaration.calendarStartedAt)
+    for (const [startId, start] of openStarts) {
+      if (start.taskId !== taskId) continue
+      const startMs = instant(start.timestamp, 'timestamp')
+      if (startMs < calendarStartedAt || complete)
+        fail('aet-v2.invalid-open-segment', startId)
+      const conflict = taskIntervals.find((interval) =>
+        overlaps(interval, { start: startMs, end: latestEvidenceAt + 1 })
+      )
+      if (conflict)
+        fail(
+          'aet-v2.overlapping-agent-segments',
+          `${startId} overlaps ${conflict.startEventId}`
+        )
+    }
+    const taskExclusiveCoverage = exclusiveCoverage.filter(
+      (interval) => interval.taskId === taskId
+    )
+    const reportingBoundary = options.postMerge
+      ? Date.parse(complete.timestamp)
+      : complete
+        ? Date.parse(complete.timestamp)
+        : latestEvidenceAt
+    const assertInDomain = (start, end, eventId) => {
+      if (start < calendarStartedAt || end > reportingBoundary)
+        fail(
+          'aet-v2.evidence-outside-lifecycle',
+          `${eventId} outside ${declaration.calendarStartedAt}..${new Date(reportingBoundary).toISOString()}`
+        )
+    }
+    for (const interval of taskIntervals)
+      assertInDomain(interval.start, interval.end, interval.startEventId)
+    for (const event of nonAet.filter((item) => item.taskId === taskId))
+      assertInDomain(
+        Date.parse(event.startedAt),
+        Date.parse(event.endedAt),
+        event.eventId
+      )
+    for (const event of taskMilestones)
+      assertInDomain(
+        Date.parse(event.timestamp),
+        Date.parse(event.timestamp),
+        event.eventId
+      )
+    for (const event of taskEstimateRevisions)
+      assertInDomain(
+        Date.parse(event.timestamp),
+        Date.parse(event.timestamp),
+        event.eventId
+      )
+    const coverage = [
+      ...taskIntervals.map((interval) => ({
+        end: interval.end,
+        eventId: interval.startEventId,
+        start: interval.start
+      })),
+      ...taskExclusiveCoverage
+    ].sort((left, right) => left.start - right.start || left.end - right.end)
+    if (!options.allowIncomplete && !coverage.length)
+      fail('aet-v2.uncovered-timeline', `${taskId} has no capacity coverage`)
+    let coveredThrough = calendarStartedAt
+    for (const interval of coverage) {
+      if (
+        interval.end <= calendarStartedAt ||
+        interval.start >= reportingBoundary
+      )
+        continue
+      const clippedStart = Math.max(interval.start, calendarStartedAt)
+      const clippedEnd = Math.min(interval.end, reportingBoundary)
+      if (!options.allowIncomplete && clippedStart > coveredThrough)
+        fail(
+          'aet-v2.uncovered-timeline',
+          `${taskId} gap ${new Date(coveredThrough).toISOString()}..${new Date(clippedStart).toISOString()}`
+        )
+      coveredThrough = Math.max(coveredThrough, clippedEnd)
+    }
+    if (!options.allowIncomplete && coveredThrough < reportingBoundary)
+      fail(
+        'aet-v2.uncovered-timeline',
+        `${taskId} gap ${new Date(coveredThrough).toISOString()}..${new Date(reportingBoundary).toISOString()}`
+      )
+    tasks[taskId] = {
+      aetMilliseconds: options.allowIncomplete ? null : aetMilliseconds,
+      measuredLowerBoundAetMilliseconds: options.allowIncomplete
+        ? aetMilliseconds
+        : null,
+      calendarCycleMilliseconds:
+        reportingBoundary - Date.parse(declaration.calendarStartedAt),
+      categoryMilliseconds,
+      clockMilliseconds,
+      completedAt: complete?.timestamp ?? null,
+      corrections: corrected.correctionTaskIds.filter(
+        (correctionTaskId) => correctionTaskId === taskId
+      ).length,
+      estimateHistory: [
+        {
+          estimateMinutes: declaration.originalEstimateMinutes,
+          kind: 'original',
+          recordedAt: declaration.recordedAt
+        },
+        ...taskEstimateRevisions.map((event) => ({
+          approvalSource: event.approvalSource,
+          estimateMinutes: event.revisedTotalEstimateMinutes,
+          kind: 'revision',
+          reason: event.reason,
+          recordedAt: event.timestamp,
+          scopeDeltaMinutes: event.scopeDeltaMinutes
+        }))
+      ],
+      estimateRatio: options.allowIncomplete
+        ? null
+        : aetMilliseconds / (declaration.originalEstimateMinutes * 60_000),
+      estimateVarianceMilliseconds: options.allowIncomplete
+        ? null
+        : aetMilliseconds - declaration.originalEstimateMinutes * 60_000,
+      firstPrReadyAt: firstPrReady?.timestamp ?? null,
+      latestApprovedEstimateMinutes,
+      latestApprovedEstimateRatio: options.allowIncomplete
+        ? null
+        : aetMilliseconds / (latestApprovedEstimateMinutes * 60_000),
+      latestApprovedEstimateVarianceMilliseconds: options.allowIncomplete
+        ? null
+        : aetMilliseconds - latestApprovedEstimateMinutes * 60_000,
+      lifecycleFinal: Boolean(complete),
+      lifecycleStatus: complete
+        ? 'final-complete'
+        : merged
+          ? 'intermediate-post-merge'
+          : 'active-intermediate',
+      measurementComplete: !options.allowIncomplete,
+      mergedAt: merged?.timestamp ?? null,
+      metric: METRIC,
+      originalEstimateRatio: options.allowIncomplete
+        ? null
+        : aetMilliseconds / (declaration.originalEstimateMinutes * 60_000),
+      originalEstimateMinutes: declaration.originalEstimateMinutes,
+      originalEstimateVarianceMilliseconds: options.allowIncomplete
+        ? null
+        : aetMilliseconds - declaration.originalEstimateMinutes * 60_000,
+      remediationCycles: taskIntervals.filter(
+        (interval) => interval.category === 'remediation'
+      ).length,
+      reportingBoundaryAt: new Date(reportingBoundary).toISOString(),
+      taskTitle: declaration.taskTitle,
+      workClass: declaration.workClass
+    }
+  }
+
+  for (const interval of intervals)
+    if (!declarations.has(interval.taskId))
+      fail('aet-v2.missing-declaration', interval.taskId)
+  for (const event of [...nonAet, ...milestones, ...estimateRevisions])
+    if (!declarations.has(event.taskId))
+      fail('aet-v2.missing-declaration', event.taskId)
+
+  return {
+    corrections: corrected.corrections,
+    measurementComplete: !options.allowIncomplete,
+    metric: METRIC,
+    schema: 'rn-launcher/aet-v2-report/v1',
+    tasks
+  }
+}
+
+export function stableAetV2Json(value) {
+  if (Array.isArray(value)) return `[${value.map(stableAetV2Json).join(',')}]`
+  if (value && typeof value === 'object')
+    return `{${Object.keys(value)
+      .sort()
+      .map((key) => `${JSON.stringify(key)}:${stableAetV2Json(value[key])}`)
+      .join(',')}}`
+  return JSON.stringify(value)
+}
+
+export const aetV2Contract = Object.freeze({ metric: METRIC, schema: SCHEMA })