Skip to content
Back to skills

Follow Up

ASecurity

Maintain the developer-activated Paseo workspace's PR history, remaining obligations, developer-sent repair batches, and archive readiness.

  • 2 stars
  • 0 votes
  • 0 copies
  • 0 views
  • Added November 18, 2026
ai-agentsrustgonodegit

Works with

  • cli
  • mcp

Security analysis

A100/100

Scanned November 18, 2026

npx -y skills add tomgrin10/paseo-follow-up --skill follow-up --agent claude-code

Installs into .claude/skills of the current project.

Are you the author of Follow Up?

Add the live security badge to your README. It updates with every re-scan.

Security grade badge for Follow Up
[![Security: A — Skills Directory](https://www.skillsdirectory.com/api/skills/tomgrin10-follow-up/badge)](https://www.skillsdirectory.com/skills/tomgrin10-follow-up)

More formats (shields.io, HTML) on the badges page. Keep it an A: scan every change in CI with Pro.

Download with Pro
SKILL.md
---
name: follow-up
description: Maintain the developer-activated Paseo workspace's PR history, remaining obligations, developer-sent repair batches, and archive readiness.
---

Keep routine bookkeeping silent. Never announce tracker calls, say the sidebar was updated/synced, recap its visible state, or add plugin-status commentary/final paragraphs. Put receipts, evidence and sync summaries in the tools. User-facing messages cover actual work outcomes or decisions/blockers requiring the developer. Only discuss sidebar status when explicitly asked. A bookkeeping-only continuation should finish its tool calls without repeating the previous answer or sending a sidebar recap.

Use the follow-up MCP tools when available, or the bridge in `FOLLOW_UP_CLI` with `node "$FOLLOW_UP_CLI" call <tool> '<json>'`. Tracking starts through Track this workspace or a user-enabled project default. The developer sends a batch by clicking its control, or enables Auto for this workspace. Enrollment never enables Auto or sends messages. Polling sends only when this workspace has explicit Auto consent. Use `enroll_workspace` to refine the inferred goal. Never ask the developer to enter a goal, enroll, register PRs or maintain this tracker. Recovery is an optional human action under Workspace → Recovery, available repeatedly. It never gates manually maintained tracking, repairs, deployment tasks or main-agent Done, and Auto never starts recovery. Recovery batches run in a separate agent in the same workspace. Recovery reads an evidence file and updates only tracking metadata, preserves main-agent ownership, never edits code or pushes, and cannot declare Done. Acknowledge its own recovery batch; its metadata access ends after acknowledgment. On an inventory batch, recover all workspace-produced PRs/stacks and unfinished work from the full conversation, earlier compactions, local transcripts and git/Graphite history. Historical candidate URLs are references, not proof of ownership. Read `workspace_status` after compaction and before declaring completion.

Register every PR this workspace produces with `register_pr` after submission. Register parents before children and update parent relationships after a split/reparent. Use meaningful stack names and preserve existing history. A Linear issue is optional. A referenced external PR is not automatically owned by this workspace. When you merge a PR yourself (no human review), register it with `agentMerges: true` so Follow-up never asks the developer to add reviewers or merge it.

Maintain this sidebar during normal work without a developer reminder. Before ending a normal turn, reconcile the goal, owned PRs, stack relationships and substantive tasks, then call `sync_workspace` with a concise summary, even if no changes were needed. This confirms bookkeeping only; it never declares Done or starts repair/recovery work. The provider hooks restore these instructions at session start, on each prompt and after compaction, and allow one missed-sync continuation. Never transfer ownership or ask the developer to update the sidebar.

Record remaining implementation, decisions, deployment verification, migrations, and other post-merge work using `update_obligation`. Dependencies use `owner/repo#number` keys. Tasks are substantive follow-up, never approve/merge/deploy checklist entries: PRs already track their lifecycle. Use concise action titles, for example "Verify vendor resolution in production", and put dependencies in afterPrs rather than restating the merge steps. Tasks are manual unless explicitly scheduled with trigger={event:"now"|"merge"|"deploy",delayDays:0}. Only set a trigger from the developer’s requested timing; never infer timing from a title or enable_follow_up alone. Merge/deploy triggers require owned afterPrs; delayDays=14 waits fourteen days after the last dependency event. Now requires no PR dependencies or delay. Deployment timing starts at the first verified fully serving observation and remains conservative when history is unknown. Preserve existing trigger fields on updates; trigger=null makes a task manual. Auto controls delivery, not timing or production permissions. Delivery still respects workspace Auto consent and production permissions. A deploy tag or merged PR alone never establishes deployment. When you end a turn waiting on work Follow-up can't see (a detached release, a reload window, a job that pings you later), declare it as a task with status `waiting` and a title that says what and when ("beta.68 installs in the 11:21 reload window"), then mark it done when the ping arrives: Home lists the workspace under Waiting with that title instead of asking the developer for anything. Record result evidence for done or waived obligations. Preserve fields while updating; leave an obligation blocked when the developer must act.

Ask the developer decisions you can't make yourself with `ask_question`: a short title, the question, lettered options A, B, C… each with what it means for them, and `recommend` set to the option you'd pick. Set `big` (a few plain words on why) only when building ahead would send something off this computer, set something people or programs outside the repo rely on, or most of the remaining work would build on the answer. Link the PR or task it is about. The reply states the developer's question mode: Stop (end your turn and wait), Work around (the default: build nothing the answer affects, keep working on the rest) or Keep building (build your recommendation and change course if they pick another; big questions still wait). Follow it exactly. The developer answers in Follow-up and the answer arrives in your chat as `Follow-up answer Q<n> …`, already recorded. If they answer in chat instead, call `record_answer`. Withdraw a question that no longer matters with `withdraw_question`. A task you mark blocked also becomes a question; update the task once the decision arrives.

If you keep a spec for the workspace, usually a Claude artifact summarizing the goal, decisions and status, register its link with `set_spec` after the first publish and keep republishing to the same URL. Follow-up also picks up artifacts published from the workspace's root sessions on its own, but an explicit `set_spec` wins over detection, and a link the developer sets in Follow-up wins over both.

Repair, obligation and completion batches contain only a `Follow-up batch <batchId>` header and ordered tasks. Read `workspace_status` and refresh live conditions before acting; skip resolved tasks. Process dependent PRs bottom to top, one PR fully before the next. How to submit, restack and address review comments depends on the workspace's PR workflow, which `workspace_status` reports as `prWorkflow` (`mode` graphite or github, and `reviewFix`, the repository's review-fix command or null for the built-in steps); the session instructions spell it out. With Graphite: submit through Graphite with `--publish` and follow the repository's safe reparent procedure for merged parents. With plain GitHub: push the branch (`gh pr create` for a new PR, `gh pr ready` when it leaves draft), keep stacked PRs as a chain of base branches, restack with `git rebase --update-refs` and `--force-with-lease`, and retarget a child with `gh pr edit --base` after its parent merges. For review comments use the configured command, or read the unresolved threads with `gh`, fix and verify, push, then reply to each addressed thread and resolve it. Preserve uncommitted work. Do not merge or archive. For post-deploy tasks, verify the currently serving revision contains every dependency and record behavioral results separately from deployment evidence. Call `acknowledge_batch` with the header's batchId and a concise result before ending the turn; use blocked for work requiring a decision. Acknowledge completion batches before declaring Done. Production actions still follow the workspace's existing authorization.

When the whole goal is fulfilled, call `declare_done` with the outcome. Resolve returned blockers first. A merged stack alone is insufficient. Done labels the workspace; the developer archives it. New scope, PRs, or obligations reopen it.

Stakeholder replies belong in follow-up. When the developer asks for an update to a requester, use `update_obligation` with a concise action title and `communication` containing the original Slack `threadUrl`, `recipient`, `purpose` (`progress` or `verified`), and the actual developer `authorization`. Capture these from the conversation; never ask the developer to fill in tracking data. A historical mention or a requester asking for a bug fix is not permission to post as the developer. Empty authorization keeps the task out of delivery even with Auto on. Preserve destination and authorization when updating; pending duplicates for the same thread/recipient/purpose reconcile into one task.

Send the requested progress update using fresh evidence: what is fixed, what is deployed, what has been verified, and the blocker/next step. Read the original thread first and avoid repeating an equivalent existing update. For a final update, record a separate `purpose=verified` task such as "Verify the vendor fix and update the requester", with deployed `afterPrs` dependencies. Deployment alone does not authorize a success claim; verify behavior before replying. Existing production permissions still apply. A communication-only request does not authorize running queued repairs, benchmarks or migrations.

Use the agent's authorized Slack connection to post in that exact thread, then save the actual sent message permalink in `communication.replyUrl`, mark the task done and record result evidence. If an equivalent update already exists, verify and record its permalink instead of posting again. A draft, a read-only connection or an uncertain send remains blocked; record the reason and inspect the thread before retrying. Do not change connector permissions or claim a message was sent. Communication tasks with no reply receipt prevent Done and cannot acknowledge their batch completed. Waive only with explicit decision evidence. The plugin tracks and dispatches these tasks; it does not create a separate Slack posting identity or scan channels in the background.

A developer-confirmed scope exclusion is durable. Use `exclude_stack` with the evidence/reason and related obligation IDs when correcting an unrelated stack. Its records remain in the exclusion audit; do not re-register excluded PRs or stacks from historical mentions. External dependencies are not owned PRs. Recovery handoffs preserve the main owner and require the exact initial user task in a replacement agent after the original recipient is archived. Keep acknowledgment results within 2000 characters.

Root agents also get Follow-up's action tools: anything the developer can click in Follow-up, an agent can do too. Read freely (`list_prs`, `inbox_list`, `inbox_brief`, `workspace_about`, `agent_settings`, `display_settings`, `follow_settings`, `project_settings`, `pr_workflow`, `reviewer_settings`, `onboarding_status`, `priorities`, `usage`, `overseer_status`). Act only when the developer asks: PR actions (`add_reviewers`, `merge`, merge-when-ready), workspace controls (`send_repairs`, `set_auto_send`, `clear_hold`, `retry_batch`, `track`, `run_recovery`), every Settings tab (`set_display` including trust bypass, `set_follow_settings` for Auto-send defaults, `set_project_tracking`, `set_pr_workflow` for workflow, merge method and review fix per repository, `save_reviewers`, `set_agent_setting`, `set_onboarding` to finish or skip setup), Home (`set_priorities`, `rerank_priorities`, the Overseer), and the inbox for other agents (`sign_off`, `snooze`, `set_finish_flags`, `inbox_act`, `brief_action`, `answer_question`). Writes are planned: the first call is a dry run showing what changes; run it with `confirm: true` and its `planId`. Every agent action is audited. Never sign yourself off, answer your own brief, or act on your own inbox row.

Use native Follow-up MCP tools first. Their replies contain current work or the exact changed record; workspace_status with detail=full retrieves complete history. Already-running sessions can use the CLI compatibility bridge with --compact, or omit that flag for older full-response scripts. Run the bridge with list to inspect schemas. Unknown argument names are rejected; dependencies are afterPrs with owner/repo#number strings. Ordinary task updates preserve omitted dependencies/evidence/schedule, while completion requires fresh result evidence.

Attribution

Is this your skill, or is something wrong with this listing? Request removal or report an issue. Author removals are honored within 72 hours.

View all in ai-agents →

Comments

Loading comments…

Newsletter

Get the weekly list of safe new skills, and the ones we pulled.