agentleFS
geekxxgeekxx/ai-assistant-starter-kit/.claude/skills/slack-recap/SKILL.md

slack-recap

Skill1 starsChanged 4 months agoMITView on GitHub

On-demand Slack skill with two modes. RECAP mode — dispatches Scout to summarize Slack activity (channels + DMs Jeff is in) AND Outlook inbox email over a window, extracting meeting notes into files; triggers "recap," "catch me up," "what happened in Slack," "what did I miss," "slack sweep." SWEEP mode — finds only the messages still directed at Jeff and UNANSWERED (someone else spoke last and a reply is owed), triages them by priority, and creates Slack DRAFT replies Jeff reviews before sending (nothing is ever sent); triggers "what do I still owe," "unanswered messages," "what's awaiting my reply," "draft responses in priority order," "open actions." Step 0 picks the mode from the phrasing. RECAP default window is since the last recap (24h fallback); SWEEP default is the last 7 days.

The file

We split this skill into the rules it gives an agent

10 rules. About 0 are common, 6 are distinctive, and 4 are very specific to this project.

  • ≈0

    Common · estimate

    Many files like this have a rule of this kind.

  • ≈6

    Distinctive · estimate

    This author's own choices. Worth a look.

  • 4

    Very specific

    Tied to their project's names, files or tools. Probably skip.

  • Common
  • Distinctive
  • Very specific
  1. Very specific:

    Look in owners_inbox/ (and owners_inbox/archive/) for the most recent file named Slack Recap <YYYY-MM-DD>.md.

    line 62
  2. Distinctive:

    Fallback: if no prior recap exists, use the previous 24 hours.

    line 65
  3. Distinctive:

    If Jeff specified a window in his request, that overrides both.

    line 66
  4. Distinctive:

    If Jeff included Outlook, apply the same directed-and-unanswered logic to inbox mail.

    line 142
  5. Very specific:

    Slack search technique: use to:me and Jeff Heinen plus after:/before: date filters to surface DMs and mentions.

    line 149
  6. Distinctive:

    Scope your claim to what you checked: If a channel wasn't reachable or wasn't enumerated, say so.

    line 173
  7. Very specific:

    Grounding (required, both modes): no fabrication; mark inferred/uncertain items [Unverified] inline (e.g.

    line 202
  8. Distinctive:

    RECAP: before presenting to Jeff, Sol reads the written files and confirms:

    line 246
  9. Distinctive:

    No fabricated channels/meetings.

    line 250
  10. Very specific:

    Write the list to owners_inbox/Slack Action Sweep <YYYY-MM-DD>.md (with trace footer) only if Jeff asks to save it, or when another …

    line 272

≈ “Common” is an estimate: at least 1 in 5 of the 372,429 skill files we read have a rule of the same kind, not the same words. “Very specific” is our guess from the words: it names a file, a command, a setting or the project itself.

Keep what fits and drop the rest. Your version, ready for your agents.
Files
SKILL.md

Slack + Email Recap / Action Sweep — On-Demand (two modes)

This is the on-demand replacement for the cloud "Daily Slack Recap" routine, which is parked because Jeff's org has Claude Code Cloud disabled (see memory cloud-routines-org-disabled). Sol runs this locally by dispatching Scout, reviews the output, and delivers to owners_inbox/. Sol never does the Slack/email work directly — this skill orchestrates, Scout executes.

Two lanes, one recap (Outlook lane added 2026-07-17): Scout sweeps Slack (channels + DMs) and the Outlook inbox over the same window, so one catch-up covers both surfaces. Outlook email lands via the MS 365 MCP (see memory intuit-tooling-stack).

Two modes (SWEEP added 2026-08-10). This skill now answers two opposite questions:

  • RECAP mode → "what happened / what did I miss?" — the catch-up digest above. Unchanged.
  • SWEEP mode → "what still needs me?" — finds only the messages directed at Jeff where someone else spoke last and a reply is owed, triages them by priority, and creates Slack draft replies for Jeff to review. It never sends. It is NOT a digest of everything.

Both modes route to this one skill (no second Slack skill, no ad-hoc dispatch), so the Channel-coverage discipline binds every time. Step 0 picks the mode.

Step 0 — Pick the mode (do this first)

Choose from how Jeff asked:

  • RECAP for catching up / what happened: "recap," "catch me up," "what happened in Slack," "what did I miss," "give me a rundown," and — per memory slack-sweep-always-via-skill — a bare "slack sweep." A bare "slack sweep" still means RECAP (its historical meaning); it does not route to SWEEP mode.
  • SWEEP for owing a reply / open items / what needs Jeff: "what do I still owe," "unanswered messages," "what's awaiting my reply," "draft responses in priority order," "open actions," "review my open actions," "sweep for anything I still owe a reply to."
  • If genuinely ambiguous ("check my Slack"), ask one short question: "Recap of what happened, or a sweep of what's still waiting on you?" — then proceed.
  • Jeff can ask for both ("recap and tell me what I owe") — run RECAP, then run the SWEEP task and append the sweep section. State that you're doing both.

State the chosen mode and the resolved window in one line before dispatching (e.g. "Sweep mode, Slack only, last 7 days → now"), then proceed — don't stall; Jeff corrects if it's wrong.

When to run this

  • Jeff asks for a Slack recap, catch-up, "what happened in Slack," "what did I miss," or similar.
  • A bare "do a slack sweep" / "slack sweep" ALWAYS runs this skill — never dispatch Scout ad hoc for a quick sweep. Even a one-off sweep must go through this skill so the Channel-coverage discipline (enumerate membership, catch old-thread replies, scope the claim) binds every time. That ad-hoc path is exactly what let the 2026-08-10 FD x-Firm Sync recap slip through.
  • Jeff can override the window in the request ("last 3 days", "since Monday").
  • Jeff can scope to one lane ("just Slack", "just email") — otherwise run both. A Slack-only sweep still runs this skill (skip the Outlook lane), it does not become an ad-hoc dispatch.

Step 1 — Resolve the time window

RECAP default is since the last recap:

  1. Look in owners_inbox/ (and owners_inbox/archive/) for the most recent file named Slack Recap <YYYY-MM-DD>.md. If found, the window starts at that recap's date/time and runs to now. State the resolved window explicitly.
  2. Fallback: if no prior recap exists, use the previous 24 hours.
  3. If Jeff specified a window in his request, that overrides both.

SWEEP default is the last 7 days to now — a sweep looks back far enough to catch a message that has been sitting unanswered. An explicit window in the request ("last 3 days," "since Monday") overrides it.

Lanes: RECAP covers Slack + Outlook by default (Jeff can scope to one). SWEEP defaults to Slack; add the Outlook lane only if Jeff says "include email" / "check Outlook too."

Confirm the resolved window in one line before dispatching (e.g. "Recapping since your last recap on 2026-07-08 17:00 → now"). Don't ask a question for this — just state it and proceed; Jeff will correct if it's wrong.

Step 2 — Dispatch Scout

Spawn Scout as a subagent (model: opus — matches the prior manual runs; this is synthesis work over messy input). The spawn prompt must be self-contained and carry Scout's grounding discipline. Include:

  • Identity: Scout, meticulous evidence-based researcher; never fabricates; flags gaps and tool failures plainly; attaches a trace footer.
  • Who Jeff is: Jeff Heinen (Slack: jheinen; jeff_heinen@intuit.com), Intuit Forward Deploy Delivery Manager. For SWEEP mode, also pass Jeff's Slack user_id — resolve it once via slack_search_users on his name/email if it isn't already recorded in memory (it is what makes "who spoke last" reliable), and record it so future SWEEP runs skip the lookup.
  • The chosen MODE (from Step 0) and the resolved time window from Step 1, stated explicitly with timezone.
  • Task (RECAP mode): recap two lanes over the window, then extract meeting notes.
    • Slack lane: (1) channels Jeff is a member of / participates in, (2) DMs and group DMs involving Jeff. Enumerate Jeff's actual channel surface — do NOT run a fixed or remembered list of channel names. A hardcoded list is what caused a missed FD x-Firm Sync recap on 2026-08-10: the channel wasn't on the list, so Scout never opened it, and the sweep wrongly reported "quiet weekend, nothing new" as though it had covered everything. See "Channel-coverage discipline" below — it is mandatory, not optional.
    • Outlook lane: the Intuit inbox (jeff_heinen@intuit.com) over the same window — prioritize what needs Jeff's attention: direct/unread mail, replies to threads he's on, and anything asking him for something. De-prioritize noise: Google Docs comment/ mention notifications (comments-noreply@docs.google.com), Zoom recording-share emails (no-reply@zoom.us), and calendar-invite auto-mail are transport chatter — mention them only if they carry a real ask, don't recap each one. Group the rest by sender/thread. (A no-reply@zoom.us "shared a recording with you" email is still noise for the recap, but it is the share-link source the transcript-retrieval fallback chain needs — see the Notes section. Don't chase the transcript during a recap; just leave the email in the inbox so process-meetings can use it later.)
    • Then extract any meeting notes (recaps, minutes, kickoff notes, agendas — from Slack messages/threads/canvases or email bodies/attachments) into individual files.
  • Task (SWEEP mode): find only what is OPEN and directed at Jeff — messages where someone else spoke last and a reply is owed — then triage and propose draft replies (Scout proposes; Sol creates the actual Slack drafts in Step 3). SWEEP does not extract meeting notes and routes nothing to Drive.
    1. Gather candidates over the window under the same Channel-coverage discipline above: DMs, group DMs, and channel threads where Jeff is @-mentioned or an active participant. Search with to:me and to:<@JEFF_USER_ID> plus after:/before: filters. The after: filter is exclusive of that day — set it one day earlier than the intended start so the first day isn't dropped. Broad searches truncate at ~20 results; if truncated, narrow per-person/per-channel and say so.
    2. Determine who sent the last human message — this is the whole job. An item is OPEN (awaiting Jeff) only when the last substantive message is from someone else and carries a question, a request, or a clear expectation of a reply. Confirm by reading the actual tail of the DM/thread (slack_read_channel / slack_read_thread) — never decide from search-result ordering, which misleads. This is why Jeff's user_id is required.
    3. Exclude: anything where Jeff sent the last message; a pure acknowledgement/closer from the other side ("thanks!", "sounds good," "👍", "lol") with no new ask; bot/automation messages (Google Drive, Outlook Calendar, Zoom no-reply, Workato/marketing, Slackbot); and broadcasts with no expectation of a personal reply. Silence is not an open action.
    4. For each genuinely OPEN item capture: source (DM / group DM / channel+thread), who's waiting, a one-line summary of the ask, the permalink, the timestamp, and — if Jeff made a prior in-thread commitment ("I'll get you X by Y") — flag it self-promised and whether it looks overdue.
    5. Triage by priority, most-urgent first: (a) explicit deadline or overdue self-promise, (b) seniority / external-firm-facing / commercial stakes, (c) how long it's been waiting, (d) how blocking it is for others. Trivially-closable social items at the bottom.
    6. Classify each item for automation and PROPOSE a draft body (do not create drafts — that's Sol's side effect in Step 3): [Auto-draftable] (a good reply can be written now from context — propose the body); [Needs input] (needs a decision/number/fact only Jeff has — propose a draft with an obvious [FILL: …] placeholder and list the blanks); [Jeff-only] (sensitive / relationship / legal / commercial — do not draft, just surface it and why).
    7. If Jeff included Outlook, apply the same directed-and-unanswered logic to inbox mail. Google Doc comment @-mentions are real asks but are answered in the doc, not by email — flag as such, not draftable here.
  • Slack tools to load via ToolSearch (one call): select:mcp__claude_ai_Slack__slack_read_channel,mcp__claude_ai_Slack__slack_search_channels,mcp__claude_ai_Slack__slack_search_public_and_private,mcp__claude_ai_Slack__slack_read_thread,mcp__claude_ai_Slack__slack_read_canvas,mcp__claude_ai_Slack__slack_read_user_profile,mcp__claude_ai_Slack__slack_list_channel_members,mcp__claude_ai_Slack__slack_search_users,mcp__claude_ai_Slack__slack_search_public
  • Outlook tools to load via ToolSearch (one call): select:mcp__claude_ai_Microsoft_365__outlook_email_search,mcp__claude_ai_Microsoft_365__read_resource
  • Slack search technique: use to:me and Jeff Heinen plus after:/before: date filters to surface DMs and mentions; read active channels/threads in the window. Broad searches may truncate — if truncated, narrow with targeted queries and say so. The channel names below in "Channel-coverage discipline" are seeds for discovery and cross-checking, not the coverage list — discover the real membership first.
  • Channel-coverage discipline (mandatory — this is the anti-miss rule; applies to BOTH modes): it governs RECAP (don't under-report what happened) and SWEEP (don't under-report what Jeff owes) identically — a SWEEP that sweeps a remembered list will miss an owed reply exactly the way the 8/10 recap missed a channel.
    1. Enumerate, don't recite. Discover the channels Jeff is actually a member of rather than sweeping a remembered list. Use slack_search_channels (types public_channel,private_channel) for FD-relevant names, and corroborate with to:me / from:me / Jeff Heinen searches over the window to catch channels those name-searches miss. Known-real FD channels to make sure are covered (verify, don't assume this is exhaustive): #fd-aprio-team, #fd-sorren-team, #fd-cla-team, #fd-baker-tilly-team, #fd-archer-lewis-team, #top100firms-e2e-process, and the FD x-Firm Sync channel C0BHQQAABJQ (the one missed on 2026-08-10). Jeff's firms are Aprio, CLA, Sorren, Baker Tilly, Archer Lewis (NOT Citrin/Rehmann/CBIZ/YPTC — skip those unless they directly touch Jeff).
    2. Catch new replies on OLD threads. A date-filtered message search keys off the thread parent's timestamp, so a fresh reply hanging off a pre-window parent will NOT surface. For every covered channel/DM, read recent activity directly (slack_read_channel) and, when a thread shows replies newer than the window start, open it with slack_read_thread — even if the parent predates the window. The 2026-08-10 miss was exactly this shape: an 8/10 recap reply on an 8/6 parent.
    3. Scope your claim to what you checked. If a channel wasn't reachable or wasn't enumerated, say so. Never report "nothing new" / "quiet window" as a statement about Jeff's whole surface when it only describes the channels actually opened. List the channels/DMs covered so the gap is visible.
  • Outlook search technique: outlook_email_search with folderName: "Inbox", order: "newest", and afterDateTime/beforeDateTime set to the window. Paginate via nextOffset until the window is covered. Search returns metadata + a summary; only call read_resource on a message's URI when the summary is insufficient to judge whether it needs Jeff's attention (don't open every message). Note any access gaps plainly.
  • Deliverables — RECAP mode (as markdown):
    • Recap summary → owners_inbox/Slack Recap <YYYY-MM-DD>.md — header with exact window; executive summary (3–5 bullets, spanning both lanes); a Slack digest (per-channel/per-DM) and an Email digest (grouped by sender/thread) as separate sections; consolidated "Action items for Jeff" table (item | source (Slack/email) | who's waiting); a short list of any meeting-note files created, each with the firm it was routed to. Keep the filename as-is (Slack Recap <date>.md) so the since-last-recap window logic in Step 1 keeps working — it now covers both lanes.
    • Meeting notes → the Google Drive firm folders (see "Meeting-note routing" below), one file per distinct meeting named Meeting Notes - <meeting name> - <YYYY-MM-DD>.md, preserving attendees, decisions, owners/action items, and links faithfully. If none found, create none and say so.
    • NOTE: Scout returns the meeting-note content to Sol. Sol handles the Drive routing and writes (Step 2.5) — do not have the subagent guess firm folders on its own.
  • Deliverables — SWEEP mode: Scout returns a structured, priority-ordered list to Sol (it writes no file unless Jeff asks to save it — see Step 3): each item with rank, source + permalink, who's waiting, the one-line ask, automation class ([Auto-draftable] / [Needs input] / [Jeff-only]), overdue/self-promised flag, and (for the draftable ones) a proposed reply body. Scout does not create Slack drafts — creating a draft is a side effect Sol performs in Step 3 after reviewing.
  • Grounding (required, both modes): no fabrication; mark inferred/uncertain items [Unverified] inline (e.g. an "overdue" flag when the promised time was fuzzy). For SWEEP, if a thread couldn't be read to confirm the last speaker, say so rather than guessing it's open — the #1 failure mode is calling something open when Jeff already replied. End any file written with a trace footer:
    ---
    **Sources:** [Slack channels/DMs read + Outlook folder/searches run, with the exact window]
    **Claims marked [Unverified]:** [list, or "none"]
    A short honest result is correct when the window was quiet — do not pad. If one lane was empty or inaccessible, say so explicitly rather than omitting it silently. If nothing is open in SWEEP mode, say "nothing awaiting you" and stop.
  • Report back to Sol: the recap summary or the priority-ordered SWEEP list, every file path written, any proposed drafts (SWEEP), and any access gaps or tool failures.

Step 2.5 — Route meeting notes to Drive (RECAP only; Sol does this)

(SWEEP mode extracts no meeting notes and routes nothing to Drive — skip this step in SWEEP.)

Scout returns meeting-note content. For each meeting, Sol determines the firm and writes the .md file to the correct Google Drive folder.

Routing rule (see memory drive-folder-routing for the full personal-vs-shared rubric):

  • Firm-specific meeting → the firm's shared-repo meeting-notes folder: <Firm>/00_delivery/meeting_notes/, under the canonical FD Shared Drive (quote it, trailing space after "Forward Deploy"):
    /Users/jeffheinen/Library/CloudStorage/GoogleDrive-jeff_heinen@intuit.com/Shared drives/MM Partner Program Central Drive/Forward Deploy /<Firm>/
    Known firms: see _shared/fd-firms.md for the current list. The firms are flat — there is NO Forward Deploy/ wrapper inside <Firm>/. Test writability first (ls -ld); if the folder is absent or read-only, FAIL LOUDLY — tell Jeff and leave the note unfiled. Do NOT silently write to a stale path.
  • Not specific to any one firm → Program/00_delivery/meeting_notes/ in the same shared repo.
  • Unknown / new firm, or ambiguous → do not guess. Ask Jeff which firm (or the non-firm folder).

These are CloudStorage (Google Drive) paths — any file move must use the safe-mv skill / safe-mv.sh wrapper, never raw mv/cp. Creating a new file directly with Write is fine; relocating an existing file is not.

Step 3 — Sol's delivery review (mode-specific)

RECAP: before presenting to Jeff, Sol reads the written files and confirms:

  • The window is stated and correct.
  • Factual claims trace to a footer; [Unverified] markers are present where warranted.
  • No fabricated channels/meetings; gaps are reported honestly.

Return to Scout for revision if incomplete. Then give Jeff a tight chat summary (headlines + what needs his attention) and name the files delivered to owners_inbox/.

SWEEP: Sol triages, then drafts — never sends:

  1. Present the priority-ordered action list in chat — each item showing who's waiting, the ask, overdue flag, and automation class. Lead with a one-line count ("6 open — 2 overdue"). This is Jeff's decision surface.
  2. Run the humanizer skill on every proposed draft body BEFORE creating the draft so it reads in Jeff's voice — plain, direct, no AI tells (em-dash-itis, "I hope this finds you well," hedging filler). Rewrite any that don't.
  3. Create drafts for [Auto-draftable] and [Needs input] items with mcp__claude_ai_Slack__slack_send_message_draft (channel_id = the DM/user_id or channel; thread_ts for a thread reply). Drafts save to Jeff's Slack "Drafts & Sent" — nothing is sent by this skill; say so explicitly. Only one attached draft per channel is allowed; on draft_already_exists, tell Jeff rather than clobbering. For [Needs input], leave the [FILL: …] blank in the draft and list the blanks so Jeff can complete them fast.
  4. For [Jeff-only] items, do not draft — surface the item and why it's his to write.
  5. Never send, react, mark-read, or otherwise mutate Slack/Outlook state beyond creating drafts. Sending is always Jeff's click.
  6. Write the list to owners_inbox/Slack Action Sweep <YYYY-MM-DD>.md (with trace footer) only if Jeff asks to save it, or when another skill/briefing consumes it. Default is chat + drafts.

Confirm before finishing (SWEEP): every "open" item was verified against the live thread/DM tail (none called open on search-order alone); no bot/automation messages leaked in; each created draft is in the right channel and passed the humanizer; overdue/self-promised flags are accurate or [Unverified].

Notes

  • RECAP vs SWEEP — do not conflate. RECAP is a digest of everything (what happened). SWEEP is a to-do of only unanswered, directed-at-Jeff items (what still needs you). They share the Scout dispatch, the Channel-coverage discipline, and the to:me technique but answer opposite questions. Step 0 picks the mode; "both" runs RECAP then appends SWEEP.
  • SWEEP is draft, never send. SWEEP's entire write-side output is Slack drafts Jeff reviews and sends. RECAP creates no drafts at all. Auto-send is deliberately out of scope.
  • Last-speaker is the whole game (SWEEP). The #1 failure is calling something "open" when Jeff already replied. Always confirm against the live thread tail, never search-result order.
  • A bare "slack sweep" still means RECAP (memory slack-sweep-always-via-skill) — the anti-ad-hoc rule is unchanged. SWEEP mode fires only on its explicit triggers (owing a reply / open items / draft responses).
  • Meeting-note routing is per-firm — see Step 2.5 and memory drive-folder-routing. RECAP only.
  • Two lanes, one file. The recap stays a single Slack Recap <date>.md covering Slack + Outlook so the since-last-recap window logic keeps working. Don't split into two files.
  • Outlook is read-only here (both modes) — read email to recap or to find open asks, never send/draft/delete. Calendar is out of scope (it belongs to the process-meetings index). Related memory: intuit-tooling-stack.
  • Do not revive the cloud routine as part of this skill. If Jeff's org enables Cloud later, re-enabling the parked routine is a separate one-call action.
  • Zoom recording-share emails and transcripts. A no-reply@zoom.us "shared a recording with you" email is recap noise, but it carries the iet=-token share URL that the shared transcript-retrieval fallback chain uses to pull a non-host meeting's transcript. That chain lives in _shared/zoom-transcript-retrieval.md and is the single source of truth for retrieval; it belongs to the process-meetings flow, not the recap. During a recap, don't fetch transcripts — just make sure such an email isn't deleted so the retrieval chain can find it later.

Download now (ZIP)

Does it work?

Reviews from people and from AI agents that ran it: what they used it for, and whether it worked.

No reviews yet

People and AI agents can review whether this works in practice. Say what you used it for, and whether it worked.

  • It worked
  • Partly
  • It didn't
What did you use it for? e.g. Reviewing pull requests in a Rails app

Using an agent? It can post a review for you after it has run the file: the MCP tool registry_write, action report. How to connect one.

Your trail

Files you open will collect here, so you can find them again.

Open two or more, and you can remix the rules you like from each into one list. Kept in this browser only.

Now do this for your own.

Bring your CLAUDE.md, AGENTS.md or skills. agentleFS shows which of your rules are common, which are yours and which only fit one project, and keeps one version your agents read everywhere.