AGENT SKILL

standup

Convene the recently-active git worktrees as named agents in a markdown group chat, have them reconcile what each changed, and converge on ONE consolidated worktree. Each branch is an agent that posts to a shared STANDUP.md (YAML front matter holds the GOAL + PROMPT; the body is the chat log), then the room agrees on a merge order and a single consolidation plan in the SUMMATION. The room is filled either by time window (past 1h / 4h / 24h / 7d / all — only worktrees active in it join, so a 40-worktree machine collapses to the handful you actually touched) or by hand-picking specific worktrees and/or open GitHub PRs from a checkbox-style list. Use this skill whenever the user says "standup", "run the standup", "reconcile my worktrees", "consolidate worktrees", "merge these branches together", "merge these PRs", "combine these worktrees and pull requests", "what's everyone at", "have my worktrees check in", or wants several branch-named agents to coordinate / resolve overlapping work into one deliverable through a shared chat file — even if they don't say the word "standup".

License 许可
Apache-2.0
所属仓库
Army161/claude-mem
最近更新
2026-06-08
Stars
★ 0
Forks
0

01 前言 Front Matter

name
standup
version
1.0.0
description
Convene the recently-active git worktrees as named agents in a markdown group chat, have them reconcile what each changed, and converge on ONE consolidated worktree. Each branch is an agent that posts to a shared STANDUP.md (YAML front matter holds the GOAL + PROMPT; the body is the chat log), then the room agrees on a merge order and a single consolidation plan in the SUMMATION. The room is filled either by time window (past 1h / 4h / 24h / 7d / all — only worktrees active in it join, so a 40-worktree machine collapses to the handful you actually touched) or by hand-picking specific worktrees and/or open GitHub PRs from a checkbox-style list. Use this skill whenever the user says "standup", "run the standup", "reconcile my worktrees", "consolidate worktrees", "merge these branches together", "merge these PRs", "combine these worktrees and pull requests", "what's everyone at", "have my worktrees check in", or wants several branch-named agents to coordinate / resolve overlapping work into one deliverable through a shared chat file — even if they don't say the word "standup".
allowed-tools
[ "Bash", "Read", "Edit", "Task", "AskUserQuestion" ]

02 资源文件 2

03 SKILL.md 正文

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> --json
    

    Active = 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 prs errors (no gh / 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 is pr-<number>) in a standup group chat. Read <skill-dir>/agent-brief.md and play your part by it. The room is ~/.claude-mem/STANDUP.md; speak with node "<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 uses gh 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 AskUserQuestion for 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.

04 同仓库更多 Skills

Army161
Army161/claude-mem

wowerpoint

Turn one document into a kawaii NotebookLM slide-deck PDF. Use for "wowerpoint this", "make a deck about <file>", "turn this report into slides", or any request to render a single document as shareable narrative slides.

★ 0
Army161
Army161/claude-mem

weekly-digests

Generate a serial week-by-week narrative digest of a project's full claude-mem timeline. Splits the timeline into per-ISO-week files, then runs one consecutive subagent per week — each receiving the prior week's carry-forward block — to produce one chapter per ISO week of data. Use when asked for "weekly digests", "week-by-week story", "serial timeline", or "narrative chapters" of a project's history.

★ 0
Army161
Army161/claude-mem

claude-code-plugin-release

Automated semantic versioning and release workflow for Claude Code plugins. Handles version increments across package.json, marketplace.json, plugin.json manifests, npm publishing (so `npx claude-mem@X.Y.Z` resolves), build verification, git tagging, GitHub releases, and changelog generation.

★ 0
Army161
Army161/claude-mem

timeline-report

Generate a "Journey Into [Project]" narrative report analyzing a project's entire development history from claude-mem's timeline. Use when asked for a timeline report, project history analysis, development journey, or full project report.

★ 0
Army161
Army161/claude-mem

smart-explore

Token-optimized structural code search using tree-sitter AST parsing. Use instead of reading full files when you need to understand code structure, find functions, or explore a codebase efficiently.

★ 0
Army161
Army161/claude-mem

pathfinder

Map a codebase into feature-grouped flowcharts, identify duplicated concerns across features, and propose a unified architecture. Use when asked to "find the ideal path," unify duplicated systems, or audit architecture before a refactor. Emits a proposed unified flowchart plus per-system /make-plan prompts.

★ 0