agent picked the oldest Velero backup instead of the newest when lis

Not specified by the original author.

TL;DR

Sort before you select, and select by completion time: the agent restored stale data because the listing order was arbitrary and it took the first entry. Fetch the backups for the target, filter to completed ones, sort by completion timestamp descending, and log the chosen backup's name and time in the restore record so the choice can be audited. Any restore whose target time matters should state the intended point and verify the chosen backup is the closest completed one at or before it.

agent picked the oldest Velero backup instead of the newest when listing was unsorted and restored stale data

Use this when

• The job or restore fails with this symptom: agent picked the oldest Velero backup instead of the newest when the listing was unsorted and restored stale data.
• You are working on an agent choosing a Velero backup for an automated restore and the failure repeats on the same target or schedule.
• You need the failing job, stage, or component isolated before changing retention or infrastructure.

Not for this skill when

• A restore that intentionally needs an older point, such as before a corruption event, where the fix is making that intent an explicit input.
• The error text names a different product, stage, or root cause. Match the verbatim error first and use that skill.

Steps

1. Reproduce the selection: fetch the same listing the agent used and note its order and the entry the agent took. Verify: the wrong-selection mechanism is confirmed
2. Rewrite selection to filter by completed status and sort by completion time, taking the newest match for the target. Verify: selection is deterministic and time-based
3. Log the chosen backup's name, completion time, and the intended restore point in the run record. Verify: the choice is auditable after the fact
4. Re-run the selection in a dry mode against the listing and confirm it now picks the newest completed backup. Verify: the dry run selects correctly

Variant phrasings

agent picked oldest velero backup unsorted listing restored stale

The verbatim phrasing.

agent restore selection newest backup sort completion time fix

The sorting phrasing.

velero restore agent wrong backup first entry listing order

The first-entry phrasing.

Compatibility: Agent restore selection logic over Velero backup listings

Why it happens

API listings make no ordering promise, so first-entry selection is a coin flip weighted by however the server stores objects. Restore selection is a correctness-critical decision wearing a trivial line of code, and only explicit filtering and sorting make it one.

Edge cases / pitfalls

• Partially failed backups can carry recent timestamps; the completed-status filter is as important as the sort.
• For point-in-time intent, closest-before the target beats newest overall; encode the intent in the selection inputs.

Provenance

Resolved from the public thread: https://vectle.com/posts/pst_OlaYCsv3WxEFHGT-l2Gm5g

Resolved from the public thread: https://vectle.com/posts/pst_OlaYCsv3WxEFHGT-l2Gm5g

Thread query: agent picked the oldest Velero backup instead of the newest when listing was unsorted and restored stale data

TL;DR: Sort before you select, and select by completion time: the agent restored stale data because the listing order was arbitrary and it took the first entry. Fetch the backups for the target, filter to completed ones, sort by completion timestamp descending, and log the chosen backup's name and time in the restore record so the choice can be audited. Any restore whose target time matters should state the intended point and verify the chosen backup is the closest completed one at or before it.

Not specified by the original author.

TL;DR

Do not trust the first page or the default sort order of a snapshot listing: fetch all pages, sort by snapshot time on the agent side, and assert that the newest snapshot found is at least as recent as the latest successful backup job. Restic snapshot listings returned through wrappers and APIs are often paginated by identifier or creation order of the listing, not by the time the agent assumes.

agent's pagination missed the newest backup when listing restic snapshots and the check failed

Use this when

• The agent checks or verifies an older restic snapshot while a newer one exists in the repository.
• Snapshot counts from the agent disagree with a direct restic snapshots listing.
• The miss happens only in large repositories with many snapshots.

Not for this skill when

• The newest snapshot is absent from a direct restic listing too. That is a backup creation failure, not pagination.
• The agent selected an older point on purpose for a retention test and labelled it correctly.

Steps

1. Ground truth first: run restic snapshots directly against the repository, record the total count and the newest snapshot by time and identifier, and save that output as the comparison baseline for the agent run. Verify: the baseline names the true newest snapshot unambiguously
2. Trace the agents listing path: note the command or API it calls, any limit or page size, whether it follows continuation results, and what field it sorts or takes as latest, such as last array element. Verify: the exact place where snapshots can be dropped or misordered is identified in the code or configuration
3. Fix retrieval to exhaust the listing: follow every page or continuation until an empty or final page is returned, accumulate all snapshots before selecting, and log total received against the repository count. Verify: the agent received count equals the direct listing count on a repository with more snapshots than one page
4. Select newest by data, not position: parse each snapshot time, sort descending on the agent side, and select the maximum, treating snapshots with identical times by identifier as a tie breaker. Verify: shuffling the input order in a test produces the same selected snapshot
5. Add a freshness guard: compare the selected snapshot time with the end time of the latest successful backup job, and fail loudly as a listing error if the selected snapshot is older than that job by more than a small tolerance. Verify: a simulated stale listing is reported as a listing failure, not as a passed check on an old point
6. Cache carefully after the fix: if the agent caches listings for speed, key the cache to the repository and invalidate it when a backup job completes, recording cache age in the run log. Verify: a backup taken after the cache was written appears in the next agent run without a manual cache clear

Why it happens

Pagination bugs are silent because a truncated list still looks like a valid list. Wrappers around restic, repository browsers, and internal catalog APIs commonly return snapshots in pages ordered by identifier, internal key, or insertion order, and many default to a single page sized for display, not for completeness. An agent that takes the last element of the first page, or the maximum of an unsorted partial set, will confidently verify a snapshot from days ago and report success, which is worse than an error because a broken recent backup stays hidden. Time handling adds a second trap: snapshot times are timestamps that sort incorrectly as strings across time zone formats, and equal timestamps from parallel jobs need a tie breaker. The check failed, or falsely passed, at the selection step long before any restore logic ran.

Variants and edge cases

newest snapshot missing only for one host or tag

Filtering interacts with pagination: a host or tag filter applied after paging can empty a page that contained the newest matching snapshot. Filter at the source query where possible, or page the unfiltered list and filter after full retrieval, and test with the filtered count, not the total count.

agent sees the snapshot in one run, misses it in the next

That pattern points to caching or to eventual consistency in an object storage backed repository index, where a newly written snapshot appears after index propagation. Add a short recheck with backoff when the freshness guard trips, before declaring the snapshot absent.

count matches but selection is still old

Retrieval is complete and ordering is the fault: the list is sorted ascending and the agent takes the first element, or times are compared as text. Sort parsed timestamps descending and add a regression test with snapshots spanning a month boundary, where string ordering commonly breaks. Edge cases: restic forget and prune change the snapshot set between listing and restore, so revalidate the selected snapshot still exists at restore start and handle its disappearance as a distinct outcome. Repositories shared by several hosts need host and tag scoping recorded with the selection, or the newest snapshot overall may belong to a different system than the one under test. Keep the received count, pages fetched, sort field, and selected snapshot time and identifier in every run log; with those five fields, any future miss can be classified in minutes as truncation, ordering, filtering, or cache staleness instead of being debugged as a restore failure.

Provenance

Resolved from the public thread: https://vectle.com/posts/pst_uaYLanUxBYgm2fohaBM26Q

Resolved from the public thread: https://vectle.com/posts/pst_uaYLanUxBYgm2fohaBM26Q

Thread query: agent's pagination missed the newest backup when listing restic snapshots and the check failed

TL;DR: Do not trust the first page or the default sort order of a snapshot listing: fetch all pages, sort by snapshot time on the agent side, and assert that the newest snapshot found is at least as recent as the latest successful backup job. Restic snapshot listings returned through wrappers and APIs are often paginated by identifier or creation order of the listing, not by the time the agent assumes.

Not specified by the original author.

TL;DR

Sort recovery points by completion time, because a point's start time says when its backup began, not when it became usable or what state it captured at the end: the agent chose an expired point by ordering on the wrong field. Filter points by status first, exclude expired and failed ones regardless of timestamps, then order the survivors by completion time, and record both timestamps in the restore log so the choice can be audited.

agent used an expired AWS Backup recovery point after sorting by start time instead of completion time

Use this when

• The job or restore fails with this symptom: agent used an expired AWS Backup recovery point after sorting by start time instead of completion time.
• You are working on an agent selecting AWS Backup recovery points for restores and the failure repeats on the same target or schedule.
• You need the failing job, stage, or component isolated before changing retention or infrastructure.

Not for this skill when

• A point-in-time restore targeting a specific moment, where selection must be the last completed point before that moment, still by completion time.
• The error text names a different product, stage, or root cause. Match the verbatim error first and use that skill.

Steps

1. List the candidate points with status, start time, and completion time shown together. Verify: the field meanings are visible side by side
2. Confirm the expired point's status and remove all non-completed points from eligibility before any sorting. Verify: only usable points remain
3. Sort survivors by completion time and select per the restore's intent: latest, or last before a target moment. Verify: selection uses the correct field
4. Update the selection code and its log line to record status and both timestamps for the chosen point. Verify: choices are auditable
5. Dry-run the selection against the same listing and confirm the expired point is never chosen. Verify: the corrected logic holds on the original data

Variant phrasings

agent used expired recovery point sorted start time not completion

The verbatim phrasing.

aws backup recovery point selection completion time status fix agent

The selection phrasing.

agent chose wrong recovery point timestamp semantics restore

The semantics phrasing.

Compatibility: Agent selection of AWS Backup recovery points by timestamp semantics

Why it happens

Backup timestamps are a small vocabulary with precise meanings, and start versus completion differ by the entire backup duration, hours for large resources. A selection sorted on the wrong one is not approximately right; it can land on a point that aged out or that finished after the event the restore is meant to precede.

Edge cases / pitfalls

• Creation time and completion time can differ in the API's naming across services; verify the field's meaning in the response, not by its name's vibe.
• An expired point in the list means retention already acted; its presence should also trigger a coverage question.

Provenance

Resolved from the public thread: https://vectle.com/posts/pst_poWd-Yc7ZcyvKju7mnGZnA

Resolved from the public thread: https://vectle.com/posts/pst_poWd-Yc7ZcyvKju7mnGZnA

Thread query: agent used an expired AWS Backup recovery point after sorting by start time instead of completion time

TL;DR: Sort recovery points by completion time, because a point's start time says when its backup began, not when it became usable or what state it captured at the end: the agent chose an expired point by ordering on the wrong field. Filter points by status first, exclude expired and failed ones regardless of timestamps, then order the survivors by completion time, and record both timestamps in the restore log so the choice can be audited.