standup
π―SkillGathers your recent git branches, work folders or pull requests into one shared chat. An AI agent speaks for each one, and together they agree on a single plan for combining the work. Nothing is merged during the chat.
Installation
npx skills add thedotmack/claude-mem --skill standupRun it in a terminal; it asks which AI coding tools to install it for (Claude Code, Codex, Cursor and more).
Uses skills.sh Β· Node.js 22.20+
After installing
Ask for related work and the agent uses it on its own, or call it yourself.
/standupInstall by hand
Copy the whole skill folder from GitHub to the place below. Copying only SKILL.md can leave out files the skill uses.
Open the skill folder β- This project
.claude/skills/standup/ - All projects
~/.claude/skills/standup/
These paths are for Claude Code. For other tools, the command above puts it in the right place.
SKILL.md
View on GitHub βFacilitate a read-only standup across git worktrees, branches, or PRs to compare changes and produce one consolidation plan.
standup β facilitate a group chat between branch-agents
You're the facilitator. Each of the user's git worktrees (and any PRs they pick) joins a shared markdown chat as its own agent, and the agents reconcile their scattered work into ONE consolidated worktree. You convene the room, run the conversation in rounds, and carry the outcome back β the reconciling happens in the chat, between the agents.
The room is one shared file (default ~/.claude-mem/STANDUP.md): YAML front
matter holds the goal + prompt; the body is the transcript. Writes are
atomically locked, so agents speak at once. It is read-only β agents decide
how the merge should go; nobody commits or merges inside the room. Real git
work happens afterward via /do.
1. Fill the room
Two ways, mixable:
-
By recency (common) β worktrees active in a window:
node "${CLAUDE_SKILL_DIR}/standup.mjs" worktrees --since <1h|4h|24h|7d|all> --jsonActive = a commit or an uncommitted/staged/untracked edit in the window. If the user didn't name a window, offer 1h / 4h / 24h / 7d / all.
-
By hand β specific branches and/or open PRs:
node "${CLAUDE_SKILL_DIR}/standup.mjs" worktrees --json # local branches node "${CLAUDE_SKILL_DIR}/standup.mjs" prs --json # open PRs (via gh)Show one numbered list (worktrees + PRs, with age/title); their reply is the "checkbox." If
prserrors (nogh/ not GitHub), carry on worktrees-only.
Zero or one candidate isn't a standup β say so, offer to widen, stop. Otherwise echo the roster to confirm before you start.
2. Open the room
Set a goal + prompt that invite a conversation, not one-shot status reports:
node "${CLAUDE_SKILL_DIR}/standup.mjs" open --force --agent facilitator \
--goal "Collapse these branches/PRs into ONE consolidated worktree: what each changed, where they overlap, which becomes the target, and the merge order." \
--prompt "Facilitated rounds. Round 1: introduce your branch and its state. Then resolve the conflicts the facilitator surfaces, round by round, until the room lands on one concrete plan (target worktree + merge order + conflict resolutions). Read-only: decide, don't merge. Register AGREE when you back the plan."
3. Run it as rounds
You drive the turns β if agents watch-loop on their own the room can stall with nothing decided. Each agent speaks once per round (read β post β return); you read between rounds and bring back whoever's still needed.
Spawned agents don't inherit CLAUDE_SKILL_DIR, so resolve it once and paste the
real path into each brief:
echo "${CLAUDE_SKILL_DIR}"
Round 1 β intros (everyone, one Task message so they run together). Brief each:
You're
<branch>(a PR ispr-<number>) in a standup group chat. Read<skill-dir>/agent-brief.mdand play your part by it. The room is~/.claude-mem/STANDUP.md; speak withnode "<skill-dir>/standup.mjs" post β¦, catch up withβ¦ read. Get your bearings (cd "<path>",git log --oneline origin/main..HEAD,git status --short,git diff --stat origin/main...HEAD; a PR usesgh pr view/diff <number>), then post ONE turn: your branch, its real state, and how it should fold in. Read-only. Then return.
Reconcile. Once they've returned, read the room and list the open
items β overlaps, conflicts, competing implementations, undecided
target/order. None? Skip to the close.
Resolution rounds (cap ~4). Per open item, re-spawn only the agents it
implicates, with the specific question. Tell them to read --since <their-name>
first, then post their position and --agree if convinced. read again, update
the list. Repeat.
Close β you always write it. Stop when the list is empty, you hit the cap, or an agent errors (note "didn't report," don't block). Then write the SUMMATION yourself β don't wait for an agent to volunteer. Write it as plain prose a human can skim, not a field dump: which worktree is the target and why, the merge order in a sentence, and what's left for the human:
node "${CLAUDE_SKILL_DIR}/standup.mjs" summation --agent facilitator \
--text "Build on <worktree> β it's the only one with real code. Layer <branch>'s changes on top, then drop in the doc-only branches; skip <empty branch>. Your call before it's safe: <the one or two real decisions>. Done when it all sits in <target> and builds clean."
4. Brief the human in plain language
This is the payoff β don't hand them the raw SUMMATION, translate it. A human who didn't watch the room should understand the outcome without decoding paths, line counts, or commit hashes. Lead with the answer, then the few choices only they can make:
- What you found β one plain line per branch: who has real code, who's just docs, who's empty.
- The plan β target + merge order in a sentence or two.
- Their call β only the decisions a human must make (which implementation
wins, what to drop, anything risky), as concrete questions. Use
AskUserQuestionfor the clear-cut ones.
Keep git internals out unless they ask. Once they've settled the open calls, hand
the plan to /do to perform the merges β don't merge anything yourself
outside /do.
CLI
node "${CLAUDE_SKILL_DIR}/standup.mjs" <command> [--flags]
Defaults: agent = git branch, file = ~/.claude-mem/STANDUP.md. Every write is
atomically locked.
| command | what it does |
|---|---|
worktrees [--since 4h] [--json] | worktrees newest-first; --since N{m,h,d,w} keeps those active in the window |
prs [--since 4h] [--json] | open GitHub PRs (via gh) newest-first |
open --goal "β¦" --prompt "β¦" [--force] | create the room (--force rotates an old one aside) |
join [--message "β¦"] | add yourself + say Hello |
post --message "β¦" [--agree "β¦"] | append a turn |
agree --deliverable "β¦" | append an AGREE turn |
watch [--timeout SEC] [--interval SEC] | block until someone else posts, print it (exit 2 on timeout) |
read [--tail N] [--since AGENT] | print the chat (or only turns after AGENT's last) |
status | participants + AGREEs + consensus check |
summation --text "β¦" | write the SUMMATION, flip status: agreed |
Each spawned agent plays its turns by agent-brief.md (bundled here) β the
playbook for being one voice in the room.
More from this repository10
Claude-Mem gives Claude Code a memory that stays after a session ends. It keeps that memory in a compressed, shorter form.
claude-mem gives Claude Code a memory that lasts between sessions. It records what Claude does while you work, saves short summaries, and shows that context automatically when you start a new session.
Searches your saved Claude-Mem memory on cmem.ai to recall what happened in earlier sessions. It answers questions like what you did last time on a project, file or decision.
Lets your AI agent explore a codebase by looking at its outline first, such as function and class names, instead of reading whole files. This saves the agent's reading budget. It uses three companion tools to search code, show a file's structure, and open only the part you need.
Helps your AI agent write a step-by-step plan before building a feature. It first checks the real documentation for what is available, then splits the work into phases. Each phase has a clear goal, examples to copy, checks to prove it works, and mistakes to avoid.
Carries out a step-by-step plan by handing each piece of work to separate helper agents. After each step it checks the result, reviews the code and saves the changes to git only when the checks pass.
Writes a story-style report of a project's whole development history, based on the notes that claude-mem has saved over time. It needs the claude-mem background service to be running.
Automated semantic versioning and release workflow for Claude Code plugins, bumps package.json, marketplace.json, and plugin.json in lockstep, runs the build, tags the commit, creates a GitHub release, and generates changelog entries. Enforces 'nothing left uncommitted or unpushed' by running git status at the end.
Turns the notes claude-mem keeps about your past work into focused knowledge bases you can chat with. You pick notes by project, topic, file, or date, load them into a session, then ask questions about past decisions and fixes.
Reviews a design against Dieter Rams' ten principles of good design, scoring each one with evidence. It then recommends a new design, a refinement or a redesign, and writes a ready-to-use prompt for /make-plan.