Prompt placeholders

Execute these commands in this Claude Code session, one by one, show full output for each, do not skip any, do not summarize:

1. claude plugin marketplace update claude-brewcode
2. claude plugin update brewmod-placeholders@claude-brewcode

After all commands succeed, run `/reload-plugins`. If `/reload-plugins` is unavailable, tell me to type `exit` and run `claude` again. Run the commands now.

Update Claude Code first: claude update (2.1.301+). Dev mode, no install: claude --plugin-dir ./brewmod-placeholders. Needs node on the PATH (the bundled command hook runs as plain Node). Mods use the hooks module API, which is early access.

User typed `++r` — Two-phase review discipline is active for this turn:

[REVIEW DISCIPLINE: DOUBLE-CHECK]
Every significant change: multi-agent review (matching reviewer expert, else
general-purpose), simplification pass first.
1) Review - finding = defect with path:line + evidence (failing command/input).
2) Double-check - reproduce each finding.
3) Fix - confirmed findings only.
Big review -> split by area, never one long pass. Brief each: goal + area +
acceptance, what's covered (don't re-litigate), who consumes the verdict;
return verdict first, then findings.

User typed `++m` — Manager mode is active for this turn:

[ROLE: MANAGER]

Manage; never code/build/test/hand-debug: the main context is for orchestration.

Protocol: 1) TaskList; graph exists -> reuse it, else TaskCreate the full graph
before any work. 2) addBlockedBy/addBlocks only for real data-handoffs, else
parallel. 3) TaskUpdate owner, then launch. 4) Validate reports, integrate;
completed only when truly done; failure -> follow-up task + re-delegate. 5) all
code written -> final task: simplify, strip over-engineering.
No Task tools (CLAUDE_CODE_ENABLE_TODO_TOOLS=1 unset) -> same numbered graph
in the plan or .claude/features/<task>.md.

Sizing: one subagent = 1 deliverable, ~<=5 files, ~<=10 steps, ~<=20 min;
larger -> split. An hour-long agent = drift nobody can observe.
Scan all agents: best-matching expert per task, else general-purpose.

Spawn brief: six labeled fields. A subagent starts with an empty context, so a bare one-line task is never enough.
GOAL: task + why it exists - without the why it cannot rank the work.
ROLE: what it owns, must not touch - else two agents edit one file.
SCOPE: paths/commands in bounds and out - else the task widens.
CONTEXT: done, by whom, in parallel; only what this agent needs - else work is redone or overwritten.
CONSUMER: who or what uses the result next + the shape it must fit - else a correct result fails the next step.
DONE: acceptance, what counts as a finding, return (verdict first; evidence: command, result, unchecked; bounded; long output to a file it can write, path returned) - else it stops early or returns a dump.
Code/test briefs add: follow the closest well-built repo counterpart's
principles - additive to conventions/rules/docs, never instead.

Finish the whole job; decide without routine questions.

Plan mode: the first line becomes User typed `++m` — Manager + Plan Mode is active for this turn:; the normal text stays, then a blank line and this addition:

[ADDON: PLAN MODE]

Stay read-only: no code, board/task-state writes, installation or
configuration. Read-only expert exploration is allowed.

Include in the plan (English, token economy):
- PREAMBLE: [ROLE: MANAGER] + the 5-step protocol restated verbatim as the
  plan's opening section - this addon expires, so the plan carries the role
  into implementation, no hook needed.
- STEP 0, stated literally: "Re-assume the MANAGER role. Call TaskList; if no
  graph exists, create the ENTIRE TaskGraph now - TaskCreate for every node, or
  the numbered checklist if task tools are absent - then delegate." On exit
  this comes first: not code, not one task.
- The full TaskGraph: every task decomposed (subject, acceptance, owner
  agent, bounded scope+acceptance per spawn), dependencies marked, parallel
  branches explicit, critical path named.

Deliver the embedded role + graph, not implementation code.

User typed `+++` — Anti-drift cron is active for this turn:

# [ADDON: ANTI-DRIFT CRON]

Now: announce and create one unique session cron for the current task, hourly unless the user's interval differs, using available native scheduling tools. Record its task-specific prompt, schedule ID, timezone, tick count and stop rule. If scheduling is unavailable, report the gap without claiming a schedule exists.

Each tick rereads the goal, task-specific methodology and anti-drift rules; collects active agent updates; reconciles task statuses, dependencies and remaining work; updates the task graph, keeping all unfinished entries and only the latest 10 completed entries, with older completion evidence preserved outside the active graph. It checks delivered work against the end goal, corrects drift, and names remaining acceptance criteria, problems, blockers and user questions.

Then it emits an extremely compact report: `HH:MM TZ · tick N · elapsed`; `🟢 completed`; `🔵 active / remaining / next`; `🔴 problems / blockers / questions`; `⚪ anti-drift verdict`. Omit empty rows; use only these circles. On task completion or cancellation, stop the cron and verify its removal.

Plan mode: the first line becomes User typed `+++` in Plan mode — plan the task anti-drift cron:; the normal text stays, then a blank line and this addition:

# [ADDON: ANTI-DRIFT CRON PLAN]

Stay read-only in Plan mode: create no cron now. Plan it as an execution step instead: on exit, announce and create one unique session cron per top-level task, with its task-specific prompt, interval and stop rule recorded in that task's methodology.

brewtools 6.8.0+ ships no codeword hook, so this mod is the only provider of ++m, ++a, ++r, ++rr and +++. brewtools 6.7.x also injects them, so each block appears twice: use 6.8.0+. Override files under .claude/brewtools/manager/prompts/ and <config>/manager/prompts/ are read through the legacy key, whatever the brewtools version. To silence a token, give your override an empty body (it stays silent in plan mode too). The brewtools-side notes live in Codewords.

One Markdown file per placeholder. The file name is the placeholder name. Front matter is optional, and a file inherits unset keys from the placeholder it overrides (plan is the exception: it is per file and never inherited).

• Body. With fenced blocks, only the fenced text counts. Otherwise the trimmed text after the front matter.
• Empty body. Suppresses the token. Keys are inherited from the layer below, the body is not.
• Plan part. <name>.plan.md is the plan part of <name>, with or without front matter. In plan mode its body follows the normal text after a blank line, under the plan part’s header when it has one. An empty plan part adds nothing: no plan + tag and no plan mode adds note. A plan part with no <name>.md in any layer is sent in every mode, with a warning.
• Cap. Blocks are sorted by order, joined with a --- line and cut at 9000 characters (...[truncated]).

A plan part that adds to a normal text:

~/.claude/placeholders/ship.md
---
description: "Run the tests; in plan mode also list the release steps"
---
run the tests

~/.claude/placeholders/ship.plan.md
---
description: "Run the tests; in plan mode also list the release steps"
plan: add
---
also list the release steps

++ship sends run the tests in normal modes. In plan mode it sends run the tests, a blank line, then also list the release steps. Without plan: add the text is still added, and the status view warns.

The highest layer wins, file by file:

<config> is CLAUDE_CONFIG_DIR, or ~/.claude. Project layers come from the launch directory, not the git root.

Team organizations. Claude Code’s builtin security layer bypasses a mod’s classic.* hooks there. A bundled command hook, hooks/inject.mjs, adds the blocks instead. Verified on a Team-org and a Max profile. Enterprise was not run.

• Load. Unreadable or invalid definition files are skipped, with a toast and a line in the status view.
• Match. A name must stand alone: ++rr is not ++r. ++/ or ++\ anywhere in a message turns every placeholder off for that message.
• Inject. The module expands only inline placeholders and names unknown tokens in a toast. The command hook builds the context blocks, adds plan parts when the permission mode is plan and skips subagent deliveries.
• Show. /placeholders show, list and help are answered by the module with no Claude turn; ++r? alone in a prompt hands off to show the same way. The text shown is a port of the hook’s assembly, checked against it byte by byte.
• Mod tools. Free-text /placeholders requests hand off to Claude with list_placeholders, save_placeholder, remove_placeholder and placeholders_help. Saving refuses symlinks; removing never touches plugin defaults or legacy brewtools files. Each save or remove asks once through one dialog; no permission prompt follows.
• Plan mode. The hook records the permission mode in .state/mode-<session_id>.json in the plugin root. There is no live plan-mode signal for the band: it learns plan mode from your first prompt in it.
• Fail open. Any error returns an empty result, so a fault never blocks a prompt.
• Plugin files deleted (for example a plugin update during a running session). The band reads plugin files removed (updated?) · run /reload-plugins and one toast per session says the same. Tokens are not marked unknown and inline placeholders keep expanding, but context blocks cannot be added until /reload-plugins.