SLOPSHOPPER

followups

After each answer, 4 next-prompt options above the prompt box (keys 1-4); picking one fills the box. Replaces the single grey suggestion.

newbandcommandpromptmodel
v0.1.0MITupdated 2026-10-07tyree88/tempered_plugins/followups
A shopper browsing a rack in a slop shop
Preview · a replayed session in a sandbox
claude · ~/work/app · followups
› fix the failing auth test and add an audit log call ⏺ Read(src/auth.ts) ⎿ Read 6 lines ⏺ Update(src/auth.ts) ⎿ Added 2 lines, removed 1 line ⏺ Bash(bun test) ⎿ 3 pass, 1 fail ● Done. refresh now rejects expired claims and logs an audit event. ✻ Worked for 42s · done 4:20 PM › /followups ⎿ followups: followups is on. ────────────────────────────────────────────────────────────────────────────────────────────────────────────────────── › ? for shortcuts
README

Tempered Plugins

This repository holds plugins from Tempered Works for AI coding tools. Five plugins are for Claude Code. One plugin is for Codex.

A Claude Code "mod" is a plugin of function hooks. A function hook is code that Claude Code runs when an event occurs, for example when a tool call ends. The five Claude Code plugins here are mods. They run inside Claude Code, in the terminal and in the desktop Code tab.

What is in this repository

FolderToolWhat it does
ship-state/Claude CodeShows the git, pull request, CI and deploy state of the current repo in one line above the prompt.
timeline/Claude CodeShows a vertical timeline of the work in a side pane: what you asked, what Claude did, and what each subagent is doing.
limit-resume/Claude CodeShows your usage limits and continues a turn after a rate limit resets.
followups/Claude CodeShows 4 options for your next prompt above the prompt box after each answer. You press 1 to 4 to put one in the box.
lessons/Claude CodeFinds wins and pitfalls in your prompts. It then asks Claude to run your own win-logger and pitfall-logger skills. The status line shows how many entries you logged.
multi-harness/CodexGives Codex 6 skills to plan large work in waves and to track it to completion.
.claude-plugin/marketplace.jsonClaude CodeLists the 5 Claude Code plugins so that Claude Code can install them from this repository.

Why these plugins exist

ship-state. During a coding session, you often need to know if your work is pushed, if CI passed, and if production has the change. Without this plugin, you ask Claude, and Claude runs git and gh commands to find out. Each check costs a model turn. ship-state shows the answer on screen at all times and makes no model calls.

timeline. Long work with many steps and many subagents is hard to follow. Without a record, you ask "what is left?" and "what is the current goal?" many times. You also cannot see which model each subagent uses. timeline keeps one record per repo across sessions and shows it as a timeline.

limit-resume. When a session hits a usage limit, the work stops until you type "try again". If you are away, the session stays idle after the limit resets. limit-resume continues the work at the reset time. It also shows your usage before you reach the limit.

followups. Claude Code shows one grey suggestion for your next prompt. That suggestion is often the wrong one. followups shows 4 options in 4 directions: continue the plan, verify the work, take the alternative path, and wrap up. These options cover the usual next moves. You choose one and edit it. followups sends nothing until you press Enter.

lessons. The same mistakes happen again, and good patterns get lost. A skill that logs them is useful, but it often does not run at the right moment. lessons makes the skill run. It reads your prompts for praise, frustration, and repeated requests. When it finds one, it tells Claude to run the matching skill after Claude finishes your request. The skill always asks "Log it? y/n" before it writes. You stay in control.

multi-harness. Large product work needs a plan, branch and pull request gates, tracker updates, QA evidence, and a safe closeout. multi-harness gives Codex a repeatable method for these steps. The method is the same for every product.

Requirements

  • Claude Code with support for function-hook plugins. We tested the plugins on Claude Code 2.1.288 on macOS. All Claude Code plugins pass claude plugin validate.
  • git 2.31 or newer.
  • The GitHub CLI gh, signed in. ship-state and timeline use it for pull request, CI and deploy data. Without gh, they show only local git data.
  • Production deploy data comes from GitHub deployment records. Vercel and most hosting services create these records.

How to install the Claude Code plugins

Use one of these 2 methods.

Method 1: install from the marketplace. Run these commands in a Claude Code session:

/plugin marketplace add tyree88/tempered_plugins
/plugin install ship-state@tempered-plugins
/plugin install timeline@tempered-plugins
/plugin install limit-resume@tempered-plugins
/plugin install followups@tempered-plugins
/plugin install lessons@tempered-plugins

Install only the plugins that you want.

Method 2: load the folders directly. Clone this repository. Then add the plugin folders to the env block of ~/.claude/settings.json. Separate the folders with :.

{ "env": { "CLAUDE_CODE_PLUGIN_DIRS": "/path/to/tempered_plugins/ship-state:/path/to/tempered_plugins/timeline:/path/to/tempered_plugins/followups:/path/to/tempered_plugins/lessons" } }

New sessions load the plugins. Sessions that are already open do not.

How to use ship-state

ship-state needs no action. It starts with each session.

  1. Look at the band above the prompt. It shows the current repo and branch.
  2. Read the state from left to right:
app ⎇ feat/waitlist  ·  3 dirty  ·  ↑2 ↓0  ·  PR #312  ·  CI ⏳ 4/5  ·  prod = HEAD ✓ 2h ago
PartMeaning
3 dirty3 files have changes that are not committed.
↑2 ↓02 commits are not pushed. 0 commits are not pulled.
PR #312The branch has open pull request 312.
CI ⏳ 4/54 of 5 CI checks are complete.
prod = HEAD ✓Production runs the current commit.
  1. After a push or a merge, wait for the toast. ship-state shows "CI ✓", "CI ✗" with the failed check names, or "Live on prod".

ship-state follows Claude when Claude changes to another repo or worktree. It reads local git data every 20 seconds. It reads GitHub data every 5 minutes. After a push or merge, it reads GitHub data every 20 seconds for 10 minutes.

The band of ship-state stacks with the bands of other plugins, such as followups.

How to use timeline

  1. Type /timeline to open or close the pane. The pane also opens by itself when Claude logs the first task of a session.
  2. Read the pane from top to bottom. The newest entry is at the bottom.
  3. Read the left side for your requests and decisions. Claude writes each one as a one-line summary.
  4. Read the right side for the work:
  5. A task card shows a title, a progress bar such as ██████░░░░ 2/3, how Claude did the step, and the next step.
  6. Lines that start with ↳ show commits, pushes, pull requests and CI results for the active task.
  7. A subagent card shows the agent type, the model, the status, and the elapsed time. It also shows the current tool call (now:), the next step (next:), the number of tool calls, the tokens, and the result.
  8. Look for ⚠ no model set: inherited on a subagent card. This warning means that the subagent uses the same model as the main session, because nothing set a model for it.
  9. Hold the pointer on a card in the desktop app to see more detail.
  10. If the timeline has more than 40 entries, use ◀ older and newer ▶ to move between pages.

How timeline works:

  • The plugin adds a tool, mcp__timeline__log. It also adds an instruction of about 100 tokens that tells Claude when to log. Claude logs once for each change of direction, and once at the start, each step, the end, or a block of each task.
  • Each subagent gets a shorter instruction to log its own progress.
  • The log tool needs no permission prompt.
  • timeline stores the history per repo in ~/.claude/timelines/<repo>-<hash>/. Each session writes only its own files. Worktrees of a repo share one timeline.
  • If 2 sessions work in the same repo, each pane shows the entries of the other session within 10 seconds.
  • The desktop app draws the timeline as an image, with colors for light mode and dark mode. The terminal draws it as text. If the terminal is narrower than 70 columns, the text uses 1 column.

Usage cost: each logged entry costs approximately 40 to 80 output tokens. The instruction costs approximately 100 tokens in each session.

Privacy: the timeline files contain Claude's one-line summaries, the first 2000 characters of each subagent prompt, and commit subjects. The files stay on your computer.

Status: timeline is built and reviewed. Live testing is in progress.

How to use followups

followups needs no action. It starts with each session.

  1. Wait for Claude to finish an answer. A few seconds later, 4 options appear in the band above the prompt box. Each option has its own row: 1: … to 4: ….
  2. Read the options. Each option goes in a different direction:
  3. Continue the plan.
  4. Verify or test the work.
  5. Take the alternative path, or ask an open question.
  6. Wrap up or commit.
  7. Press 1 to 4 when the prompt box is empty. You can also click an option. The text of the option goes into the prompt box.
  8. Edit the text, or press Enter to send it. followups never sends anything by itself.
  9. To ignore the options, type your own message.
  10. To turn the plugin off or on, type /followups off or /followups on. Type /followups status to see the current setting and the last error, for example a refused model call.

When the band shows, a digit that you type in an empty prompt box picks an option. To start a message with a digit, type a space first.

The band hides while the prompt box has text, while a turn runs, and while a survey uses the band. It comes back when the prompt box is empty.

followups hides the built-in grey suggestion of Claude Code, but only after its own band has drawn once. In a surface without the band, the built-in suggestion stays.

followups makes no options for subagent turns, interrupted turns, errors, and empty answers. If you send a prompt before Haiku answers, followups drops the old reply. After /clear or a resume, followups removes the old options.

Usage cost: followups makes one Haiku call for each answered turn. A call costs approximately 2,000 input tokens and 150 output tokens. followups adds nothing to the context of the main model.

Privacy: the first 1,500 characters of your last prompt and the last 4,000 characters of the answer go to Haiku. The call uses the API client of Claude Code.

How to use lessons

lessons needs 2 skills of your own. Name them win-logger and pitfall-logger. This repository does not include them. The skills decide where an entry goes, for example a Notion database. Each skill always asks "Log it? y/n" before it writes.

  1. Add the 2 skills to Claude Code. Any skills with these names work.
  2. Work as usual. lessons watches only the prompts that you send yourself: in the terminal, in Remote Control, in your own Slack ping, and in the Claude desktop app. It ignores prompts from plugins, notifications, other sessions, and subagents.
  3. Send a prompt that shows a win or a pitfall. The table below lists the signals.
  4. Claude finishes your request first. Then Claude runs the matching skill. lessons adds a short note to your prompt to cause this. You do not see the note.
  5. Read the draft that the skill shows. Answer y to log it. Answer n to skip it.
  6. Look at the status line. 🌱 2 · ⚠ 1 means 2 wins and 1 pitfall are logged in this session. lessons counts a row when you answer y to a draft. The count resets after /clear or a resume.
  7. To turn the plugin off or on, type /lessons off or /lessons on. Type /lessons status to see the setting, the counts, and where each skill was found.
KindSignals
WinPraise, for example "perfect", "nailed it", "love this", "this is great", "exactly what I wanted". Or an ask: "log this win", "log this as a win", "add this to learnings", "remember this worked".
PitfallFrustration, for example "I already told you", "no, I said", "still wrong", "still failing", "this is the third time", "why did you change…", "not what I asked". Or shouting: several words in all capitals. Or the same request sent again: it has high word overlap with one of your last 10 prompts. Or an ask: "log this", "add this to pitfalls", "remember this lesson".

lessons avoids common false signals. These prompts do not trigger it: "exactly 3 retries", "pixel perfect", "log this error to sentry", "why did you choose zod?", "the second time I click it throws". File names such as README or CHANGELOG do not trigger it. HTTP method names do not trigger it.

lessons adds at most 1 note of each kind for each 5 prompts.

lessons looks for the skills in 2 places:

  • The skills loaded in the session. The name can also be anthropic-skills:<name>.
  • On macOS, the synced-skills folder of the Claude desktop app.

If a skill is missing, lessons shows a toast at most once a day. /lessons status shows "missing" for that skill.

Usage cost: lessons makes no model calls. A note costs approximately 40 tokens. lessons adds a note only to a prompt that matches.

Privacy: your last 10 prompts stay in memory only, for the repeat check. lessons does not write them to disk.

How to use limit-resume

limit-resume needs no action. It starts with each session.

  1. Read the status line below the prompt. It shows your usage, for example 5h 62% · 7d 41%. 5h is the 5-hour window. 7d is the 7-day window.
  2. If the 5-hour usage reaches 85%, a toast tells you. Commit your work at this point.
  3. If a turn stops because of a usage limit, the status line shows when the work continues. At the reset time plus 1 minute, limit-resume sends "Continue from where you left off".
  4. If a turn stops because of a temporary API error, limit-resume tries again after 1, 2, 4, and 8 minutes, then every 15 minutes. It stops after 12 tries.
  5. To cancel a pending continue, type any message.
  6. To turn the plugin off or on, type /autoresume off or /autoresume on. Type /autoresume status to see the current setting.

Claude Code has a built-in setting, autoContinueAtUsageLimit, that also continues after a usage limit. Do not use the built-in setting and limit-resume together for usage limits. If you do, the turn gets 2 "continue" messages.

How to use multi-harness

multi-harness is a Codex plugin. Its manifest is multi-harness/.codex-plugin/plugin.json, and its plugin name is platform-orchestrator. It is not in the Claude Code marketplace file.

  1. Install the multi-harness folder with the Codex plugin installer.
  2. Ask Codex to use Platform Orchestrator on a backlog. For example: "Use Platform Orchestrator to turn this backlog into shippable waves, branch and PR gates, tracker updates, and verification evidence."
  3. Use the templates in multi-harness/assets/templates/ for wave plans, tracker updates, QA evidence, and pull request closeout.

The 6 skills are:

SkillUse
platform-wave-orchestratorDivide a backlog into agent lanes and implementation waves.
platform-agent-patternsChoose how agents work together on a wave.
platform-pr-closeoutGate and close branches and pull requests.
platform-tracker-syncUpdate GitHub and Notion trackers.
platform-qa-evidenceCollect QA evidence for each change.
platform-safety-reviewReview work that touches sensitive data, regulated text, or trust and safety limits.

To check the folder structure, run python3 multi-harness/scripts/check_plugin_structure.py.

Development

Each Claude Code plugin has checks for its logic. Node 23 or newer runs the .ts check files directly.

node limit-resume/check.ts
node ship-state/check.ts
node followups/checks/ask.check.ts
node lessons/checks/detect.check.ts
bash timeline/checks/run.sh

To run the behavior test of followups, run claude plugin test followups. It runs 8 cases on the terminal and desktop surfaces.

To run the behavior test of lessons, run claude plugin test lessons. It runs 9 cases.

To type-check timeline, do these 2 steps:

  1. In a Claude Code session in this repository, run /plugin-types .claude/types. This command writes the Claude Code type declarations.
  2. Run tsc -p timeline/tsconfig.check.json.

License

MIT. See LICENSE. Copyright 2026 Tempered Works LLC.

Source 3 files
hooks/register.tsx 167 lines
1import { atom, read, update } from 'claude-code'
2import type { EngineInterface as Engine, Register } from 'claude-code'
3
4import type { View } from '../types'
5import { SYSTEM, buildAsk, parseOptions } from './ask'
6
7const EMPTY: View = { seq: 0, options: [], isDraft: false }
8const view = atom({ plugin: 'followups', key: 'view' } as const, EMPTY)
9
10// Counts code points, so a cut never splits a surrogate pair.
11const fit = (text: string, width: number) => {
12  const chars = Array.from(text)
13  return chars.length > width ? `${chars.slice(0, Math.max(1, width - 1)).join('')}…` : text
14}
15
16// Shared by the hooks and the top-level helpers below: the loader lets $ reach only functions declared at the top of this file.
17const s = {
18  seq: 0, // bumps on every prompt and turn; a Haiku reply for an older seq is dropped
19  lastPrompt: '', // the running turn's own prompt (turn.start), not the latest one typed
20  isDraft: false, // mirrors view.isDraft so prompt.edit writes state only on a change
21  hasSurface: false, // a band drew in this process: skips the call under -p / SDK hosts
22  lastError: '',
23}
24
25const isOn = async ($: Engine) => (await $.store.get('enabled')) !== false
26const setDraft = async ($: Engine, value: boolean) => {
27  s.isDraft = value
28  await update($, view, v => ({ ...v, isDraft: value }))
29}
30const syncDraft = async ($: Engine) => {
31  const hasText = (await $.prompt.read()).text !== ''
32  if (hasText !== s.isDraft) await setDraft($, hasText)
33}
34
35const suggest = async ($: Engine, answer: string) => {
36  const mine = s.seq
37  const reply = await $.model
38    .complete({
39      model: 'haiku',
40      effort: 'low',
41      maxTokens: 300,
42      timeoutMs: 8000,
43      system: SYSTEM,
44      prompt: buildAsk(s.lastPrompt, answer),
45    })
46    .catch((err: unknown) => {
47      // The engine refused to send (a blocked model, a bad cap): say so in `/followups`.
48      s.lastError = err instanceof Error ? err.message : String(err)
49      return null
50    })
51  if (!reply || mine !== s.seq || !(await isOn($))) return // `/followups off` mid-call writes nothing
52  if (!reply.isAnswered) {
53    s.lastError = reply.reason
54    return
55  }
56  const options = parseOptions(reply.text)
57  s.lastError = options.length >= 2 ? '' : 'unparseable reply'
58  // update re-runs this on a version miss: re-check seq so a submit in between wins
59  if (options.length >= 2) await update($, view, v => (mine === s.seq ? { ...v, seq: mine, options } : v))
60}
61
62const pick = async ($: Engine, text: string) => {
63  const filled = await $.prompt.fill({ text, mode: 'replace' }).catch(() => null)
64  if (!filled?.isFilled) {
65    s.lastError = filled?.refusal ? `fill refused: ${filled.refusal}` : 'fill refused'
66    return
67  }
68  await setDraft($, true) // a fill is not a prompt.edit
69}
70
71export const register: Register = on => {
72  on('session.start', async ($, e, next) => {
73    s.isDraft = (await read($, view)).isDraft
74    await $.command.register({
75      name: 'followups',
76      description: 'followups: next-prompt options above the prompt box on or off',
77      argumentHint: 'on | off | status',
78    })
79    return next(e)
80  })
81
82  // Registered before `/followups`, so it nests outside it (a plugin's registrations nest in order, first
83  // outermost). A local command clears the box with no prompt.edit.
84  on('command.run', async ($, e, next) => {
85    const out = await next(e)
86    void syncDraft($)
87    return out
88  })
89
90  // /clear and resume start no session.start for the new conversation: drop the old one's options here.
91  on('session.end', async ($, e, next) => {
92    if (e.reason === 'clear' || e.reason === 'resume') {
93      s.seq += 1
94      s.isDraft = false
95      await update($, view, () => ({ ...EMPTY, seq: s.seq }))
96    }
97    return next(e)
98  })
99
100  on('command.run', { command: 'followups' }, async ($, e) => {
101    const arg = e.args.trim()
102    if (arg === 'on' || arg === 'off') await $.store.set('enabled', arg === 'on')
103    if (arg === 'off') await update($, view, v => ({ ...v, options: [] }))
104    const state = (await isOn($)) ? 'on' : 'off'
105    return { text: `followups is ${state}.${s.lastError ? ` Last error: ${s.lastError}.` : ''}` }
106  })
107
108  on('prompt.submit', async ($, e, next) => {
109    s.seq += 1
110    s.isDraft = false
111    await update($, view, () => ({ seq: s.seq, options: [], isDraft: false }))
112    return next(e)
113  })
114
115  // The turn's own prompt: one typed mid-turn fires prompt.submit before this answer lands.
116  on('turn.start', async ($, e, next) => {
117    s.seq += 1
118    if (e.text) s.lastPrompt = e.text // a continuation has no text: keep the last prompt
119    return next(e)
120  })
121
122  on('turn.complete', async ($, e, next) => {
123    const result = await next(e)
124    if (e.agentId || e.reason !== 'answer' || !e.answer.trim() || !s.hasSurface || !(await isOn($))) return result
125    void suggest($, e.answer) // never hold the turn's end for Haiku
126    return result
127  })
128
129  on('prompt.edit', async ($, e, next) => {
130    const box = await next(e)
131    const hasText = box.text !== ''
132    if (hasText !== s.isDraft) await setDraft($, hasText)
133    return box
134  })
135
136  // The band replaces the engine's single grey guess. Plugin suggestions pass.
137  // Only once a band has drawn: with no band (another plugin above ours, vscode, mobile) it stays.
138  on('prompt.suggest', { origin: { kind: 'suggestion' } }, async ($, e, next) =>
139    s.hasSurface && (await isOn($)) ? { isShown: false } : next(e),
140  )
141
142  // Stacks: our rows, then whatever the plugins beneath drew (ship-state's band).
143  on('ui.render', { component: 'AbovePrompt' }, async ($, e, next) => {
144    s.hasSurface = true
145    const beneath = await next(e)
146    const v = await read($, view)
147    if (e.props.hasSurvey || e.props.isWorking || v.isDraft || v.options.length === 0) return beneath
148
149    const { Box, Button } = $.ui.resolve(e)
150    const width = e.props.bodyColumns - 3 // "1: "
151    return (
152      <Box flexDirection="column">
153        {v.options.map((text, i) => (
154          <Button
155            key={`opt${i + 1}`}
156            hotkey={String(i + 1)}
157            plain
158            label={fit(text, width)}
159            onPress={() => pick($, text)}
160          />
161        ))}
162        {beneath}
163      </Box>
164    )
165  })
166}
167
hooks/ask.ts 53 lines
1export const PROMPT_CHARS = 1500
2export const ANSWER_CHARS = 4000
3const OPTION_CHARS = 160
4
5export const SYSTEM = "You suggest the user's next message to a coding agent."
6
7// The one user message for Haiku: the last exchange, then the ask. The prompt keeps its start, the answer its end.
8export function buildAsk(prompt: string, answer: string): string {
9  return [
10    '<user_message>',
11    prompt.trim().slice(0, PROMPT_CHARS),
12    '</user_message>',
13    '<agent_reply>',
14    answer.trim().slice(-ANSWER_CHARS),
15    '</agent_reply>',
16    '',
17    'Write the 4 most useful next messages the user could send the agent.',
18    "Each one: in the user's voice, an instruction to the agent, at most 100 characters.",
19    'Each takes a different direction, in this order:',
20    '1. continue the current plan or take the next step',
21    '2. verify or test what was just done',
22    '3. the alternative path, or answer the open question in the reply',
23    '4. wrap up: commit, summarize or close out',
24    'Reply with a JSON array of exactly 4 strings and nothing else.',
25  ].join('\n')
26}
27
28// Haiku's reply → up to 4 clean, distinct options. Anything unparseable → [].
29export function parseOptions(text: string): string[] {
30  const start = text.indexOf('[')
31  const end = text.lastIndexOf(']')
32  if (start < 0 || end <= start) return []
33  let raw: unknown
34  try {
35    raw = JSON.parse(text.slice(start, end + 1))
36  } catch {
37    return []
38  }
39  if (!Array.isArray(raw)) return []
40  const seen = new Set<string>()
41  const out: string[] = []
42  for (const item of raw) {
43    if (typeof item !== 'string') continue
44    const option = item.replace(/\s+/g, ' ').trim().slice(0, OPTION_CHARS).trimEnd()
45    const key = option.toLowerCase()
46    if (!option || seen.has(key)) continue
47    seen.add(key)
48    out.push(option)
49    if (out.length === 4) break
50  }
51  return out
52}
53
types/index.d.ts 8 lines
1export type View = { seq: number; options: string[]; isDraft: boolean }
2
3declare module 'claude-code' {
4  interface PluginState {
5    followups: { view: View }
6  }
7}
8