Give someone back from time away a catch-up in the conversation that they can read in five minutes: what needs them first, what was decided without them, what changed in the work they care about, which meetings they missed and what came out of them, and what’s coming up in the next few days. Keep it to the window they were away for, and leave out anything that doesn’t change what they do next.
The value of this skill is the judgement a notification inbox, a project’s update feed or a Slack unread count can’t make: across every tool at once, which of hundreds of changes need you, which were decisions, and which happened while you were out rather than just before.
Load the teamwork-graph-context skill first and follow it for gathering context, labelling sources, keeping sensitive content out and optional publishing. This file adds what’s specific to a period of time. Apply its “Sensitive content” section strictly. A long window over someone’s own work turns up more leave, private messages and people-programme pages than a single day does. Leave out a people-programme page entirely, even as a New row, when its title or excerpt carries a level code, selection or assessment language: not quoting it isn’t enough. When the user runs the programme, keep its schedule, its meetings and the user’s own actions, in neutral words (“Send the programme update to managers”), and drop only the participant and assessment detail. An optional HTML report is built by render.py in this folder (Step 8), which applies the atlassian-design skill for you: load that skill only if the script can’t run.
This skill selects “Answer-first delivery” in teamwork-graph-context: gather and assess, answer in the conversation, then ask whether the user wants an HTML report. Do not write report data, run a renderer or create an artifact unless the user requests an export, HTML report or publication. Use the existing report layout only for that optional export. Offer Atlassian Artifacts publication only after confirming availability; exporting does not authorise publishing.
products list (see “Atlassian apps on the site” in teamwork-graph-context), say so before building, and say what the page can still show.teamwork-graph-context describes. Teamwork Graph comes first, and a connector fills only a known gap:
A long window means many more candidate changes than a daily brief, so the caps matter more. Each step states its own. In total, unless the user asks for a deeper pass:
search calls: 1 to resolve a named topic, 4 for the third-party sweep (3 terms and the Slack ID), 1 for decisions and 1 for meeting notesgetWorkActivity calls: one for the user’s own activity (Step 1), one for mentions and assignments (Step 2)getGraphContext calls, on the anchor onlygetPullRequests callsgetLoomObjectsContent reads (up to 10 recordings each)getPeopleInfo batch to name editors and authors that records give only as account IDsgetProject or getGoal, plus up to 5 linked projects or goalsHistory reads (listJiraIssueChangelogs, listConfluenceContentVersions, diffConfluenceContentVersions) are capped at 8 work items and 6 pages, chosen as Step 7 ranks them. A retry after an input error doesn’t count against a cap. Other reads of known objects don’t count, but batch them. A run is usually 35 to 50 calls. The footer reports every cap that applied (“Read the history of 8 of 31 changed work items”).
list_events call for the user’s own out-of-office events (eventType: ["OUT_OF_OFFICE"]), from 6 weeks back to now. It sets the window when the user gives no dates, and “What the user already saw” needs it either way. It’s one of the 3 calendar calls.eventType: ["OUT_OF_OFFICE"] on the user’s own calendar, and use the most recent block that ended in the last 7 days. Say which dates you used (“Oct 6 to Oct 17, from your calendar”), never the event’s title or reason. Without the connector, or with no such event, ask the user for the dates. Don’t guess.zoneinfo from the user’s getPeopleInfo profile. Pass bounds as ISO datetimes with the offset (2026-10-06T00:00:00+11:00), because getWorkActivity reads a bare date as UTC. JQL and CQL take dates as "2026-10-06"./ramp-up.A catch-up is for what the user didn’t see, and people aren’t always fully away: they check in on leave, or they’re back on a project after working on something else. So before gathering, look at what the user did themselves in the window.
getWorkActivity with scope: me, activity: authored,commented,updated, types: jira,docs,comments,pr,videos, from and to set to the window, hydrate: full and itemsPerSection: 25. hydrate: full gives each of the user’s comments its parent page, which the seen rule needs. Check each parent page’s title against “Sensitive content” before using a comment’s body, and drop both together. Note the dates of the user’s own actions and the objects they touched. This call also shows which asks they’ve already answered (Step 2).atlassianUserInfo for the account ID, and getPeopleInfo (name: "me") for the display name and timezone. You need the name to match mentions in chat snippets and owners in meeting action items.AtlassianUser, scope: me). Call getWorkPortfolio with includeDirectReports: false, kinds: ["projects", "goals"], view: "compact" and limitPerCollection: 10. The scope is work assigned to, reported by or watched by the user, pages they created, edited or are mentioned on, and those projects and goals.teamwork-graph-context describes:
JiraWorkItem), a Jira space (JiraSpace) or a board.getProject or getGoal (through discover and executeRead), or searchProjects and searchGoals with 1 or 2 key terms and limit: 10.searchProjects, searchGoals and one search (mode: STANDARD, targetApp: ALL, limit: 20) together. Compare the candidates by scope and recency. If two are equally plausible, ask. If none matches, stop and say so.getProject with include: ["description", "links", "goals", "teams", "contributors"], linkType: WORK_TRACKING and limits: {links: 20, goals: 5, teams: 5, contributors: 20}. Keep the Jira keys and epics from the work-tracking links, the linked goals, and every Confluence, Google Drive or Slack URL in the description.getGoal with include: ["description", "projects", "teams"] and limits: {projects: 20, teams: 5}. Its linked projects (up to 5, most recently updated first) join the scope.getGraphContext on the anchor’s URL or ARI with detailLevel: summary, then full for linked pages, conversations, repositories and work items only. Atlas keys don’t resolve.This is the rule the whole page rests on. Date each item by its event time, as “Dating events in a window” in teamwork-graph-context describes. One rule is specific to a catch-up:
Gather everything waiting on the user from the window. One pass, at most 1 getWorkActivity call, 1 JQL query, 1 getPullRequests call, up to 4 pages of Confluence tasks, 2 CQL queries, 3 Loom lists, 2 Loom reads and 1 email search.
searchJiraIssuesUsingJql with assignee = currentUser() AND statusCategory != Done AND (duedate <= endOfDay("+5d") OR assignee CHANGED TO currentUser() AFTER "<start>" OR created >= "<start>"), adding the topic’s project in (…) or parent in (…) clause when there is one, fields: ["summary", "status", "duedate", "priority", "updated", "created", "project", "parent"] and maxResults: 25. Keep CHANGED clauses next to an assignee = or project = clause: across the whole site with only watcher = beside it, the query timed out. Don’t use getWorkActivity with activity: assigned for this: it misses work assigned before the window.getWorkActivity with scope: me, activity: mentioned,assigned, types: jira,docs,comments,videos, from and to set to the window, hydrate: full and itemsPerSection: 25. Leave commented out: in a pilot, 23 of 25 comments it returned were the user’s own and pushed asks off the page. The user’s own comments come from Step 1’s call, and show which asks they’ve already answered. A comment with no author field can’t be judged: read its author with the product’s own tool (getLoomObjectsContent with expand: ["comments"] for Loom) or leave it out. Drop a comment along with its page when the page is board, calibration or people-programme material (see “Sensitive content”), even when it asks the user something. Treat other mentions and comments as asks when they name the user and ask a question or make a request (“can you”, “could you”, “please review”), or reply in a thread the user started. With a topic, keep only items in the scope set or naming a distinctive term.getPullRequests (through discover and executeRead) with reviewer: "me", state: "open", hydrate: "summary" and limit: "10". Each open request is an ask, open since it was created. With a topic, keep requests in the scope’s repositories or naming a distinctive term.listConfluenceTasks (through discover and executeRead) with assigned-to set to the user’s account ID, status: incomplete and limit: 250. It returns the oldest tasks first, so follow the next cursor until there is none, up to 4 pages, and say in the footer if more remained. Keep tasks created inside the window, and older ones due inside the next 5 working days.listLoomObjects (through discover and executeRead) with scope: "SHARED_WITH_ME", artifactTypes: ["MEETING_RECORDING"], createdAtRange set to the window and limit: 25, plus the same with scope: "MINE". List items carry each recording’s AI summary by default, so pass responseFields for the title, creation date and URL only, check the titles against “Sensitive content”, and read summaries only for the recordings you keep. With a topic, keep recordings whose name or summary names a distinctive term or a meeting from Step 5. Read up to 6 with one getLoomObjectsContent call with expand: ["actionItems"]. It returns the full AI summary too, and can’t be filtered, so read only recordings whose titles passed the sensitive-content check. Read a people-programme recording only when the user runs the programme, and then use only the action items that start with the user’s name. Treat “decisions” or “selection” in such a title as selection language. Loom titles carry the organiser’s date, which can be a day off from the user’s, so match a recording to a meeting by title and a day either side. Items that start with the user’s name are theirs. Also read each AI summary for “[user] will…” lines: action items can miss the user’s own promises. Skip 1:1s and mentoring sessions (a title with two names, “1:1” or “mentorship”). The response lists collaborators as email addresses. Never show them.searchConfluence with creator = currentUser() AND type in (page, blogpost) AND lastmodified >= "<90 days back>", limit: 50, or the pages Step 1 found), then run searchConfluence with type = comment AND created >= "<start>" AND creator != currentUser() AND container in (<page ids>), limit: 50.listLoomObjects with scope: "MINE", sort: "CREATED_DESC" and limit: 25, with no date range, because comments arrive on older videos. Read the 10 most recent with one getLoomObjectsContent call with expand: ["comments"], and keep comments from other people created inside the window.to:me after:2026/10/06 -category:promotions -category:social -category:updates). Read subjects, senders and snippets only, keep messages from people that ask something, and say in the footer that email was searched through the connector because the graph held none.Merge duplicates: a Loom action and the Jira item that tracks it are one item with two sources.
A decision is a choice someone recorded as made: an approach chosen, a date agreed, scope cut, a request approved or declined. One pass, at most 1 CQL query and 1 search, plus the project and goal records already read.
getProject or getGoal with include: ["highlights"], highlightType: "DECISION" and limits: {highlights: 20}, and keep highlights created inside the window. Without a topic, do this for the projects and goals from getWorkPortfolio, most recently updated first.searchConfluence with the scope’s spaces (or, with no topic, contributor = currentUser() OR watcher = currentUser()) and AND (label in ("decision", "decisions", "decision-log") OR title ~ "decision") AND lastmodified >= "<start>", limit: 25. Meeting notes don’t share a title pattern (Loom’s are “[meeting title] [date]”), so decisions from meetings come from item 4 instead. For each candidate, read the outline (getConfluenceContent, detail: outline), then the full page only for those with a decision table or a “Decisions” heading, and keep the decisions dated inside the window.search (mode: STANDARD, targetApp: ALL, limit: 20) with the topic’s distinctive term (with no topic, the first search term from Step 4.5) plus “decided” or “agreed”. Keep a result only if it’s inside the window and its snippet states a decision in plain words (“we decided”, “agreed to”, “we’re going with”, “approved”, “signed off”). A proposal, a question or “let’s discuss” is not a decision.Never infer a decision from a status change, a closed work item, a moved date or a title. A work item closed as Won’t do is a Scope change in Step 4, unless a record says who decided and why. Each decision names what was decided, who decided or recorded it (the highlight’s or page’s author, or the person the snippet quotes), when, and the source. When a recording says only that the group agreed, write “agreed in the [meeting] on [date]”. Never name a decider the source doesn’t name.
Changes made by someone else, inside the window, to the work in scope.
searchJiraIssuesUsingJql with the scope clause (project in (…), parent in (…), or with no topic (assignee = currentUser() OR reporter = currentUser())) AND updated >= "<start>" ORDER BY updated DESC, fields: ["summary", "status", "issuetype", "assignee", "duedate", "priority", "created", "resolutiondate", "parent", "updated"] and maxResults: 50. If it returns 50, run it once more with searchResultMode: "count" for the candidate total, and with resolved >= "<start>" AND resolved < "<exclusive end>" for the number done. The updated query finds candidates, including items edited again after the window: count only confirmed events inside the window as changes, and report the candidate total separately. Work items created or resolved inside the window are dated by those fields. For the others, rank as Step 7 describes and read the history of the top 8 with listJiraIssueChangelogs (through discover and executeRead): it’s oldest first, so call it with maxResults: 1 to read total, then read the last 10 entries with startAt: total - 10. Keep entries inside the window that someone other than the user made, for status (especially to Blocked or Done), assignee, due date, priority and new blocking links. Use fromString and toString for what changed.getWorkPortfolio), call getProject with include: ["updates", "dependencies"] and limits: {updates: 10, dependencies: 20}, or getGoal with include: ["updates", "projects"] and limits: {updates: 10, projects: 20}. Read target date moves from each update’s previousTargetDate and targetDate, and status changes by comparing each update inside the window with the one before it. Use latestUserUpdate, not system updates. A project with no update inside the window is “No update since [date]”, which is a finding only if it was due one.searchConfluence twice with a parenthesized scope clause (space in (…) or ancestor = <id>; with no topic, creator = currentUser() OR contributor = currentUser() OR mention = currentUser() OR watcher = currentUser()), followed by AND type in (page, blogpost), limit: 25: once with AND created >= "<start>" AND created < "<exclusive end>" for New pages, and once with AND lastmodified >= "<start>" ORDER BY lastmodified DESC for edit candidates. Keep the latter query open-ended: a page edited both during and after the window must still be considered. CQL results carry no dates (their lastModified is relative text, “about 4 hours ago”, and expand is ignored), so the bounded created query identifies New pages, while version history dates edits.
listConfluenceContentVersions with limit: 100, following the cursor until a version is older than the window (live docs autosave dozens of versions a week). Choose the baseline as the last version before the start, and the comparison endpoint as the last version before the exclusive end. Ignore later versions even when one is the current version.diffConfluenceContentVersions only between those chosen versions, and summarise that diff in one sentence. If both endpoints are the same version, there was no edit in the window. A page created during the window is New rather than an edit requiring an older baseline. If complete history shows the page was created after the window, leave it out as a later creation. If history is incomplete and cannot establish the endpoints, report that the change couldn’t be checked; never substitute the current version or its body.getPeopleInfo batch. Drop edits by the user and pages edited only by them. Keep each edit’s source date inside the window; later edits do not supply its date or summary.getPullRequests with scope: "all", state: "merged", mergedSince set to the start, the scope’s repo list or query set to a distinctive term, hydrate: "summary" and limit: "20". With no topic, use author: "me", updatedSince set to the start and hydrate: "full" instead, and keep only pull requests someone else reviewed, approved, requested changes on or merged inside the window. The user’s own merges are already seen. Merged pull requests are Shipped. With author: "me", leave scope out: scope: "all" with a person fails (“accountId/name/email require scope user or scope org”). If mergedAt is null, date the pull request by updatedAt and say “updated”, not “merged”. If the result says partial: true, report “no results”, not “none”.search calls (mode: STANDARD, targetApp: THIRD_PARTY, limit: 30), one per distinctive term, plus the user’s Slack ID once you have it from a snippet. Use 1 to 3 distinctive words of each. With no topic, take the terms in this order: the titles of the user’s own most active objects from Step 1 (the pages, decks and videos they made or edited most), then their active projects from getWorkPortfolio, then recurring meeting titles. Search has no date filter, so keep results whose lastModified is inside the window and drop the rest. A pass with nothing inside the window is a result to report, not a reason to skip it.
after:2026-10-06), and say which gap it filled.At most 3 calendar connector calls and 1 search.
list_events from the start to the end of the window with eventType: ["DEFAULT"], orderBy: "startTime" and pageSize: 100. With a topic, pass fullText set to the most distinctive term (and a second call for a second term if the first returns nothing). Keep meetings the user was invited to and didn’t decline. Leave out personal, leave, travel and wellbeing events by title, and don’t count them. Skip 1:1s and mentoring sessions, as Step 2.5 does. Without a topic, keep only recurring meetings with 3 or more attendees and meetings that left a recording or notes. Events from a group calendar with the guest list hidden (guestsCanSeeGuests: false) are broadcast sessions: keep them only if the user presented or organised. Leave out meetings the user attended (see “What the user already saw”), and count them in the footer.search (mode: STANDARD, targetApp: ALL, limit: 20) for “Notes - [title]” or “[title] meeting notes” for the most important meeting with no recording. Give each meeting one line: the one decision or action that matters to the user, or “No notes or recording found”. Cap at 6 meetings, most relevant first (meetings the user organises, then the topic’s own, then the rest).list_events from now to 5 working days ahead, with the same filters. Keep up to 5 topic meetings (with no topic, recurring meetings with 3 or more attendees, one-off meetings in the next 2 working days, and any meeting tied to a Needs you item, including a 1:1), plus due dates from Step 2 and project target dates from Step 4 inside those 5 days. Link a meeting to the calendar’s day view, not its htmlLink.htmlLink (its eid encodes an email address).Read only what the page will show. Batch reads of known objects: one getGraphObject call for up to 25 Atlassian objects and Drive docs, one JQL key in (…) query for work items mentioned in text, and getConfluenceContent (detail: outline or summary) for pages. Third-party items that won’t hydrate are cited by their snippet, as teamwork-graph-context describes. Check every result against “Sensitive content” before using it.
One type per row:
getJiraIssue (view: evidence).Leave out asks Step 2 found answered. Drop asks whose moment has passed (a review for a merged pull request, a link wanted for a session that’s over). Rank by when it bites: Overdue, then Due soon by date, then Blocking, then Asks and Reviews tied to something dated (a meeting in Coming up, a deck or doc in use, a due date), then other Asks and Reviews oldest first, then Assigned, then Action. Keep up to 8, and count the rest in the footer.
One type: Decided (success). Rank decisions that change the user’s own work or dates first, then scope and approach decisions for the topic, then the rest, newest first within each. Keep up to 6. A decision the user is asked to act on also gets a Needs you row, which links to it.
One type per row:
Relevance. With a topic, keep a change only if it’s in the scope set (Confirmed) or names a distinctive term (Found by search). With no topic, keep it only if it touches work the user owns, is assigned, wrote or is named on. Drop housekeeping: formatting edits, score nudges, attendee tweaks, label changes, and bulk resyncs (many items changed by one actor within a few minutes).
Ranking. Blocked, Off track, At risk, Date moved, Scope, Shipped, New, Update. Within a type, changes to the anchor itself come first, then newest first. Don’t rank by priority field, number of edits or how long a thread is.
Grouping. Group rows by area: the epic or project for Jira and Projects, the space or page tree for Confluence, the channel or folder for third-party items. Show up to 4 groups and 12 rows in total, the group with the highest-ranked row first. Fold groups with a single row into a last group, “Other”, whose heading isn’t a link and which can mix apps, so a lone Slack or Drive change isn’t dropped by the cap. If any third-party change survived ranking, at least one shows. Fold Shipped rows when a group has more than 3: one row, “8 work items done, including ATLAS-101 and ATLAS-104”, linking the JQL search. Count everything left out in the footer.
“While you were away”: two or three sentences, at most 60 words. The first names the one thing to do first and why. The second names the most important decision or change. The third gives the shape (“41 work items moved and 2 projects changed status across Jira, Confluence and Slack”). Use only facts from Steps 2 to 5. Never mention why the user was away.
Stop when each pass has run once: needs you (Step 2), decisions (Step 3), changes from each source in Step 4, including the third-party search, and meetings (Step 5). A pass that failed twice is “Not run” in the footer, with the reason. One extra call is fine if it could change the top Needs you item or the top decision.
None. This skill is read-only. It doesn’t reply, transition work, complete tasks or change meetings. If the user asks to act on an item, confirm the exact change first, as teamwork-graph-context describes.
/meeting-prep for the next topic meeting, or /status-check or /dependency-map when a project or goal changed status.Ask whether the user wants this exported to an HTML report. If they have already explicitly requested an export, HTML report or publication, proceed with that requested build without asking again. Otherwise stop here until they answer; a normal invocation of this skill does not request a report. Follow the shared availability and confirmation checks before offering or performing publication.
Only after the user requests the report, write its data as one JSON file and run the renderer in this folder:
python3 <this skill's folder>/render.py catchup.json catch-up-<topic>.html
example.json in this folder (made-up sample data). Copy its keys and fill them from the steps above. Text fields, links, lozenges and icons follow the shared rules in the atlassian-design skill’s references/data-format.md. Leave out a key you have nothing for.{"type", "text", "source", "when"}: type is the lozenge, source is the smart link (or a list of them) for the source line, and when is the event date. A row can carry an excerpt as quote and quoteFrom.topic. The renderer counts Needs you and decisions itself. Give counts.changes when the changes found are more than the rows shown. Keys the example doesn’t use: summaryHeading (“Since Oct 5” when Step 1 found the user active), decisionNotes and meetingNotes (the extra lines under an empty or partial section), and counts.needYou and counts.decisions when there are more than the rows shown.references/hand-built.md in this folder.The rules below say what the renderer builds, and what each part of the data must hold.
Every row is one sentence of about 25 words, with its source and the event date. Use absolute dates (“Oct 9”), because a window is days or weeks long. Old items still waiting say “Open since Sep 29”.
h1 (“Ledger”), or “Your work” with no topic. Then one row with the meta line on the left and count lozenges on the right (they wrap below on phones).
calendar icon with the window and its length (“Mon, Oct 6 to Fri, Oct 17 · 10 working days”), and “From your calendar” when Step 1 took it from an out-of-office event.ai-sparkle in --ds-icon-discovery), or Since [start] when Step 1 found the user active on most of the window’s working days: the summary at 24px line height. Underneath, in small subtlest text, the apps actually used: “Generated from Jira, Confluence, Projects, Slack and Google Calendar. Check it before acting on it.”flag): rows ranked as Step 7 says. If there’s nothing, show “Nothing is waiting on you.” in subtlest text.decision): one row per decision. The sentence says what was decided and who decided it (“Amara Lindqvist decided to keep the old search index until Nov 14”), and the source line has the smart link and date. If there are none, show “No decisions you missed in this window.”, add “[N] from meetings you attended aren’t repeated.” when the seen rule left some out, and add in subtlest text that decisions made only in calls or direct messages can’t be seen.changes): a small subheading per group (the area’s name as a smart link, or plain text for “Other” and for a group of the user’s own items, such as “Your Loom videos”), then its rows. Items found by search carry the “Found by search” chip as teamwork-graph-context describes. If there’s nothing, show “No changes to this work between [start] and [end].”video): one row per meeting: a fixed-width date column (“Oct 8”), then the title in medium weight, a meta line (attendee count, organiser, “weekly” when recurring), and the one line from Step 5 with its recording or notes smart link. A meeting with no notes says so in subtlest text. With none, show “No meetings you missed in this window.” and, when attended meetings were left out, add “[N] meetings you attended aren’t shown.” With the Teamwork Graph fallback, end the card with its limitation line.clock): up to 5 rows for the next 5 working days, with the date, the title and why it matters (“Ledger review, Tue, Oct 22: the plan changed on Oct 14”). Leave it out when there’s nothing.teamwork-graph-context describes, plus:
Follow the mockup rules in teamwork-graph-context.
Static only. A catch-up covers a fixed window and is read once, on the way back in. For what changes after that, the user runs /catch-up again with a new window.
teamwork-graph-context, offer a private, read-only copy named “Catch-up: [topic], [start] to [end]” (“Catch-up: Ledger, Oct 6 to Oct 17”), or “Catch-up: your work, …” with no topic. Put the window and counts in the description. Publish only if requested; report export alone does not authorise it. Create a Confluence page instead only if the user asks.