open-asks

Preview · a replayed session in a sandbox

claude · ~/work/app · open-asks

› 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 › /asks ⎿ open-asks: No open asks. ⎿ open-asks: /asks done <ids> drops answered ones. ────────────────────────────────────────────────────────────────────────────────────────────────────────────────────── › ? for shortcuts

README

Darling Data — Claude Code plugins

A Claude Code plugin marketplace from Darling Data.

/plugin marketplace add erikdarlingdata/claude-plugins

Plugins

`sqlserver-query-plans`

Teaches Claude to read a SQL Server execution plan and say what is actually slow, and why.

/plugin install sqlserver-query-plans@erikdarling

Point Claude at a .sqlplan file and ask. The skill is model-invoked — you do not need to call it explicitly.

The hard part of plan analysis is not spotting operators. It is knowing which numbers mean what they appear to mean. This plugin is built mostly out of the conclusions that sound authoritative and are wrong:

Cost percentages are estimates in every plan, including actual plans. Nothing recomputes them after execution. The 97%-cost operator is routinely not the slow one, and an operator shown at 0% can consume the entire runtime.
Row-mode operator times are cumulative. Ranking operators by raw ActualElapsedms ranks them by depth and always crowns the root node. Batch mode reports standalone times. Exchange operators report times that are close to meaningless.
EstimateRows is per-execution; ActualRows is a total. Without dividing by ActualExecutions, the inner side of every nested loop looks catastrophically underestimated when it may have estimated perfectly.
Missing-index requests are hints, not DDL. Equality columns come out in arbitrary order, existing indexes are ignored, and the Impact figure is a percentage of an estimated cost.
A scan is not a defect and a seek is not a virtue. Judge by rows touched and time spent.

It also ships scripts/extract.py, which flattens a .sqlplan into a compact digest. This is not a convenience:

.sqlplan files are UTF-16, so grep silently matches nothing and reports no error. A negative result from grep on a plan file is worthless.
Some plans are UTF-8 bytes that still declare encoding="utf-16", because they were opened and re-saved. Strict XML parsers reject them.
A trivial two-table join is 120 KB. Real plans run to megabytes. Reading one into context wastes the context and still misses things.

The extractor handles the encoding, computes correct self-time attribution (subtracting children in row mode, within a thread rather than across threads in parallel plans, and not at all in batch mode), normalizes cardinality per execution, and recognizes the optimizer's default-guess selectivity fingerprints. --node N drills into a single operator; --sql recovers full statement text.

Requires Python 3 (standard library only). Without it, the skill degrades to a documented grep-based fallback and says plainly what it cannot determine.

GitHub Copilot CLI

This plugin also works in GitHub Copilot CLI, which reads the same SKILL.md and plugin.json format.

copilot plugin marketplace add erikdarlingdata/claude-plugins
copilot plugin install sqlserver-query-plans@erikdarling

Or add just the skill, without the marketplace:

/skills add ./plugins/sqlserver-query-plans/skills/query-plan-analysis

As in Claude Code, the skill is model-invoked: point Copilot at a .sqlplan and ask.

Claude Code mods

Small hook modules for people who run several agents at once. Each one is a plugin of its own. Install only the ones you want, and set their options in /config (or under pluginConfigs in settings.json). They need a Claude Code version that loads plugin hook modules.

`subagent-fence`

Stops the mistakes an unattended agent makes that cannot be taken back.

/plugin install subagent-fence@erikdarling

For the main session and every subagent it refuses four things. A force-push. A push to a protected branch. A git command that skips the repository's hooks. Killing processes by name (pkill, killall, taskkill /IM, Stop-Process -Name), because a name match can kill another session's processes.

Three more guards are off until you set them. One bans folders: nothing reads, writes or enters them. One keeps a subagent from editing a plain git checkout, or running a changing git command there, so it works in its own worktree. One stops a subagent reading a big text file whole instead of by offset and limit.

`model-allowlist`

Checks the model a subagent is spawned with.

/plugin install model-allowlist@erikdarling

A pinned model id goes stale: a dated or versioned name keeps pointing at an old model after the tier moves on. This refuses a spawn that names one and asks for a tier alias (opus, sonnet, haiku) instead. A spawn with no model is always allowed, because the agent file or the parent decides then.

You can add rules of your own. One example: the lane agent runs Sonnet, and Opus only when the brief says design, security or hard debugging. With no rules, every alias is allowed.

A rule applies when the spawn's agent type matches the first pattern and it names that model (* for any model). The brief must then match the brief pattern, or the spawn is refused. Leave the brief pattern empty to refuse the pairing outright. The message is optional and can use {type} and {model}. Patterns are case-insensitive regular expressions. A rule that does not parse is skipped. For example:

^(lane|worker-.*)$ => opus => \b(design|security|hard[- ]debug) => {type} runs sonnet; name the reason in the brief to use opus.

`seat-resume`

Brings interrupted sessions back after a crash, a reboot or a closed terminal.

/plugin install seat-resume@erikdarling

The plugin writes one small file per interactive session: its id, name, folder, permission mode and last activity. It marks the file when the session ends. /resume-sessions lists the sessions that died or were interrupted in the last 72 hours, with the command that reopens each. The script's -Launch switch reopens all of them in terminal tabs. Sessions you left with /exit, Ctrl+C or /clear stay closed. The plugin name still says "seat", but everything you see says "session".

This one is Windows only. The bundled script (scripts/resume-sessions.ps1) is PowerShell. It compares Windows process start times to tell a live session from a reused process id. It reopens tabs in WezTerm or Windows Terminal. Nobody has tried the plugin on macOS or Linux.

The Claude config folder is CLAUDE_CONFIG_DIR when that is set, otherwise .claude in your home folder.

`open-asks`

Keeps the questions Claude asks you from scrolling away. Every time a reply asks you something or leaves a decision to you, Claude records it. The question stays in a band above your prompt, with Claude's recommended answer, until you answer, decline or drop it. Claude gets ask_add, ask_resolve and ask_list tools. You get /asks (done <ids>, clear, hide, show). Open asks are saved per session, so a resumed session still has them.

/plugin install open-asks@erikdarling

Option	Default	What it does
`maxBandAsks`	6	Most asks the band draws. The rest stay in `/asks`.
`maxQuestionChars`	400	Longest question or recommendation shown before it is cut.
`keepDays`	30	Saved asks from other sessions are removed after this many days. 0 keeps them.

`subagent-band`

A live view of your subagents. The band above the prompt has one row per running subagent: type, model, effort, steps, context size, advisor calls and estimated cost. /fleet opens a pane with every subagent of the session, finished ones included. /subagent-cost totals the estimated cost by agent type and by issue number in the description, with the main session's own cost. /steer <id> <text> sends a running subagent a message. Claude gets a cheap subagent_vitals tool, so it does not have to read output files to check progress. Costs are list-price estimates, not your bill.

/plugin install subagent-band@erikdarling

Option	Default	What it does
`priceTable`	`opus:4:20, sonnet:2:10, haiku:1:5, fable:10:50`	Input and output USD per million tokens for each model family. A model id is matched by containing the family name.
`cacheWriteMultiplier`	1.25	Cache write price as a multiple of the input price.
`cacheReadMultiplier`	0.1	Cache read price as a multiple of the input price.

`usage-budget`

Watches the account's 5-hour and 7-day usage windows. A toast tells you each time a window crosses a percent. Past a higher percent, Claude also gets a one-time note so it can stop starting optional work and write its handoff. Past the last one, new subagents are refused until the window resets.

/plugin install usage-budget@erikdarling

Option	Default	What it does
`warnPercents`	`70, 85, 95`	Percents that raise a toast, once each per window.
`tellModelAtPercent`	85	From here the model is told as well. 0 never tells it.
`spawnGatePercent`	95	A new subagent is refused when either window is at or past this. 0 turns the refusal off.

`subagent-wall`

A wall-clock limit for subagents. After a warning time, a subagent is told to finish up. After the limit, it can only run git and gh commands and write .md or .txt files. It commits, reports and ends instead of running on. It also nudges a code-changing subagent that has a lot of context but no edited file to stop exploring and make the change. The main session is never limited.

/plugin install subagent-wall@erikdarling

Option	Default	What it does
`warnMinutes`	45	Minutes before a subagent is told to finish up. 0 turns the warning off.
`limitMinutes`	60	Minutes before it is held to `git`, `gh` and note writes. 0 turns the limit off.
`noEditNudgeK`	100	Thousands of context tokens before the no-edit nudge. 0 turns it off.
`codeAgentTypes`	`general-purpose`	Comma-separated subagent types that get the no-edit nudge.

pi

This repository is also a pi package: the root package.json declares every plugins/*/skills and plugins/*/extensions directory, and pi reads the same SKILL.md format the other two harnesses do. Install straight from git — no marketplace step:

pi install git:github.com/erikdarlingdata/claude-plugins

As everywhere else, the skill is model-invoked: point pi at a .sqlplan and ask.

`pi-session-resume` (pi only)

Your machine restarts for updates with a dozen pi sessions open; this brings them all back with one command, as terminal tabs, in their original directories, with full history:

pi-resume-sessions

An extension (auto-loaded by the install above) records every open interactive session; the pi-resume-sessions script reopens the interrupted ones — Ghostty tabs on macOS, tmux anywhere. Sessions you quit deliberately (Ctrl+D, /quit) stay closed; sessions killed by a reboot, a closed window, or a crash come back. Idle-time filters keep abandoned sessions from resurrecting.

The script needs a one-time symlink onto your PATH, and macOS needs a one-time Automation permission — see plugins/pi-session-resume/README.md for both, plus the design notes. This one is pi-only: Claude Code and Copilot CLI don't load pi extensions.

`pi-subagent-watchdog` (pi only)

Background subagents only report back when they finish — nothing wakes the orchestrator while one wedges on a giant grep or balloons from 200k to 2M tokens. This extension (auto-loaded by the install above) polls every running subagent's live vitals — tokens, cost, context %, tool uses, turns, wall clock, compactions — and batches nearby threshold crossings into one compact orchestrator check-in. Full structured records persist outside LLM context; per-agent and fleet-wide rate limits keep the watchdog from becoming its own token amplifier. Two orchestrator postures: guide (assess with judgment) and strict (thresholds are budgets — wrap up by default, one evidence-cited extension max). Optional automatic hard stop handles the truly wedged, with the outcome reported from the RPC reply rather than assumed. An optional exact model invariant hard-stops any top-level child that bypasses the manager's pre-spawn model policy. Optional per-agent cost signal and hard stop, plus session and daily USD budget warnings. The CLI surfaces also identify each child's effective model and thinking level.

Humans get a /watchdog panel (vitals, manual check-ins, steering, hard stop) plus /watchdog help | status | config | reload — config edits apply live, no session restart. See plugins/pi-subagent-watchdog/README.md for signals, modes, and design notes. Requires the pi-subagents extension; pi-only for the same reason as above.

`pi-subagent-guardrails` (pi only)

Token-budget guardrails for multi-agent setups, built after an overnight orchestration burned through its usage limit (95% of the spend came at more than 150k context). It has three pieces:

guardrails.md: the written rules for fan-out caps, model tiers, context discipline, session length and ranking.
A context-wall extension, loaded only into subagents through their agent files. It tells the child its own size at 150k and 200k. At 250k it refuses everything but git/gh and markdown writes, so the agent commits and reports instead of being aborted with its work lost.
A lane agent type for code-editing lanes: Sonnet, its own worktree, draft PRs, no fan-out tools.

The wall is deliberately not auto-loaded, because it would wall off your interactive session too. See plugins/pi-subagent-guardrails/README.md for install and the recommended watchdog and pi-subagents settings.

Not a plugin: the pi setup guide

pi-setup-guide.md — a distilled ~15-minute setup for pi written for Claude Code ex-pats: install, model/thinking defaults, the trust model, a Claude-to-pi habit translation table, a tested-together extension stack, full source for a few small quality-of-life extensions (refusal fallback, tab-title status, ! command wake-ups + autocomplete), how to point pi at years of accumulated Claude Code memory instead of migrating it, and a troubleshooting section of the gotchas that actually happened. The plugins in this repo (§11–§13 of the guide) slot into that stack.

About

Built by Erik Darling at Darling Data. SQL Server consulting, training, and free tools: <https://erikdarling.com>

License

MIT

Source 2 files

hooks/register.tsx 278 lines

1import { atom, read, update } from 'claude-code'
2import type { EngineInterface, Register } from 'claude-code'
3
4import type { Ask, Book } from '../types'
5
6// One entry in the plugin's own store per session id, so a resumed or restarted session keeps its open asks.
7// A new session id (/clear) starts empty. An entry is removed when its last ask is settled.
8const KEY_PREFIX = 'asks:'
9const DAY_MS = 86400000
10const ADD = 'mcp__open-asks__ask_add'
11const RESOLVE = 'mcp__open-asks__ask_resolve'
12const LIST = 'mcp__open-asks__ask_list'
13
14// Sent once per session in the system prompt (static text, so it caches); the tool descriptions say the rest.
15const RULE = {
16  id: 'open-asks:rule',
17  scope: 'session',
18  text:
19    'Open asks: every time a reply asks the user a question or leaves a decision to them, record each one with ' +
20    'ask_add before the reply ends: the full question with the context needed to answer it, and your ' +
21    'recommendation. When a user message answers, declines or moots one, call ask_resolve with its id before acting ' +
22    'on it. Whenever a reply mentions open asks, write each one out in full with your recommendation; never refer to ' +
23    'them by id or number alone.',
24} as const
25
26const book = atom({ plugin: 'open-asks', key: 'book' } as const, { asks: [], nextId: 1 } as Book)
27const isHidden = atom({ plugin: 'open-asks', key: 'isHidden' } as const, false)
28
29// The session the entry belongs to: followed by follow(), '' for a run that never started one.
30let sessionId = ''
31
32// The limits come from the plugin's options; register() sets them before any hook runs.
33let maxText = 400
34let maxShown = 6
35
36const clip = (text: string, max: number) => (text.length > max ? `${text.slice(0, max - 1)}…` : text)
37const oneLine = (text: string) => text.replace(/\s+/g, ' ').trim()
38const line = (ask: Ask) => `[${ask.id}] ${clip(ask.text, maxText)}${ask.from ? ` (for ${ask.from})` : ''}`
39const rec = (ask: Ask) => (ask.recommendation ? `Recommend: ${clip(ask.recommendation, maxText)}` : '')
40
41function listing(all: Book): string {
42  const rows = all.asks.flatMap(ask => (rec(ask) ? [line(ask), `    ${rec(ask)}`] : [line(ask)]))
43
44  return all.asks.length === 0 ? 'No open asks.' : [`Open asks (${all.asks.length}):`, ...rows].join('\n')
45}
46
47async function save($: EngineInterface, next: Book) {
48  if (sessionId) {
49    await (next.asks.length > 0 ? $.store.set(KEY_PREFIX + sessionId, next) : $.store.delete(KEY_PREFIX + sessionId)).catch(() => undefined)
50  }
51}
52
53// The session id changes under a running process, and no session.start fires for it: a /clear starts a new id, and
54// a restarted session can start under a new id and then resume its old one. Follow the id before each use and load
55// what is saved under it, so a resumed session gets its open asks back and a cleared one starts empty.
56async function follow($: EngineInterface) {
57  const id = await $.session.id()
58  if (id === sessionId) {
59    return
60  }
61  sessionId = id
62  const saved = (await $.store.get(KEY_PREFIX + id).catch(() => undefined)) as Book | undefined
63  await update($, book, () => (saved && Array.isArray(saved.asks) ? saved : { asks: [], nextId: 1 }))
64}
65
66async function change($: EngineInterface, fn: (all: Book) => Book): Promise<Book> {
67  await update($, book, fn)
68  const now = await read($, book)
69  await save($, now)
70
71  return now
72}
73
74// Ids from a tool input or a command argument: a number, an array of them, or text like "2, 5 7".
75function idsOf(value: unknown): number[] {
76  const raw = Array.isArray(value) ? value : String(value ?? '').split(/[\s,]+/)
77
78  return raw.map(v => Number(v)).filter(n => Number.isInteger(n) && n > 0)
79}
80
81async function add($: EngineInterface, text: string, recommendation: string, from: string): Promise<{ ask: Ask | null; all: Book }> {
82  const clean = oneLine(text)
83  if (!clean) {
84    return { ask: null, all: await read($, book) }
85  }
86  const at = await $.clock.now()
87  let made: Ask | null = null
88  const all = await change($, b => {
89    // The same question asked again keeps its id instead of piling up; a newer recommendation replaces the older one.
90    const same = b.asks.find(a => a.text.toLowerCase() === clean.toLowerCase())
91    if (same) {
92      const kept: Ask = { ...same, recommendation: oneLine(recommendation) || same.recommendation || '' }
93      made = kept
94      return { ...b, asks: b.asks.map(a => (a.id === same.id ? kept : a)) }
95    }
96    made = { id: b.nextId, text: clean, recommendation: oneLine(recommendation), from: oneLine(from), addedAt: at }
97    return { asks: [...b.asks, made], nextId: b.nextId + 1 }
98  })
99
100  return { ask: made, all }
101}
102
103async function resolve($: EngineInterface, ids: number[]): Promise<{ gone: number[]; all: Book }> {
104  const before = await read($, book)
105  const gone = before.asks.filter(a => ids.includes(a.id)).map(a => a.id)
106  const all = await change($, b => ({ ...b, asks: b.asks.filter(a => !ids.includes(a.id)) }))
107
108  return { gone, all }
109}
110
111// Entries left by sessions that never settled their asks go after keepDays, so the store does not grow for ever.
112async function prune($: EngineInterface, keepDays: number) {
113  if (keepDays <= 0) {
114    return
115  }
116  const cutoff = (await $.clock.now()) - keepDays * DAY_MS
117  for (const key of (await $.store.keys()).filter(k => k.startsWith(KEY_PREFIX) && k !== KEY_PREFIX + sessionId)) {
118    const old = (await $.store.get(key)) as Book | undefined
119    const newest = Math.max(0, ...(old?.asks ?? []).map(a => a.addedAt))
120    if (newest < cutoff) {
121      await $.store.delete(key)
122    }
123  }
124}
125
126export const register: Register = (on, options) => {
127  maxText = Math.max(40, Number(options.maxQuestionChars ?? 400))
128  maxShown = Math.max(1, Number(options.maxBandAsks ?? 6))
129  const keepDays = Number(options.keepDays ?? 30)
130
131  on('session.start', async ($, e, next) => {
132    const started = await next(e)
133    sessionId = ''
134    await follow($)
135    await prune($, keepDays).catch(() => undefined)
136
137    await $.command.register({
138      name: 'asks',
139      description: 'The questions this session is waiting on you for. /asks done <ids> drops answered ones; /asks hide|show|clear',
140    })
141    await $.tool.register({
142      name: 'ask_add',
143      description:
144        'Record a question or decision you are waiting on from the user. It stays in a band above their prompt until ' +
145        'settled, so it does not get lost in scrollback, and the user answers from the band alone: never make them ' +
146        'scroll back or ask what it means. Call it every time your reply asks the user something or leaves a decision ' +
147        'to them, one call per question. text is the full question in plain words with the context needed to answer ' +
148        'it (the issue number, what is at stake, the numbers that matter), up to about 300 characters, no internal ' +
149        'jargon. recommendation is your answer and its reason in one sentence. For a question another agent asked ' +
150        'you to relay, set from to the name of that agent. Returns the id.',
151      inputSchema: {
152        type: 'object',
153        properties: {
154          text: { type: 'string', description: 'The full question with the context needed to answer it, as the user would read it.' },
155          recommendation: { type: 'string', description: 'Your recommended answer and its one-line reason.' },
156          from: { type: 'string', description: "The name of the agent whose question you are relaying; omit for your own." },
157        },
158        required: ['text', 'recommendation'],
159      },
160    })
161    await $.tool.register({
162      name: 'ask_resolve',
163      description:
164        'Remove open asks that the user answered, declined or made moot, by id. Call it as soon as a user message ' +
165        'settles one, and before acting on the answer. Also when you settle one yourself because it no longer applies.',
166      inputSchema: {
167        type: 'object',
168        properties: { ids: { type: 'array', items: { type: 'integer' }, description: 'The ids from ask_add or ask_list.' } },
169        required: ['ids'],
170      },
171    })
172    await $.tool.register({
173      name: 'ask_list',
174      description: 'The open asks with their ids. Use it after a compaction, or when unsure which ids are still open.',
175      inputSchema: { type: 'object', properties: {} },
176    })
177
178    return started
179  }).catch(($, e, next) => next(e))
180
181  on('prompt.compose', async ($, e, next) => {
182    const composed = await next(e)
183
184    return { sections: [...composed.sections.filter(s => s.id !== RULE.id), RULE] }
185  }).catch(($, e, next) => next(e))
186
187  // Observers: catch an id change (a resume, a /clear) before the band draws again.
188  on('prompt.submit', async ($, e, next) => {
189    await follow($)
190
191    return next(e)
192  }).catch(($, e, next) => next(e))
193
194  on('turn.complete', async ($, e, next) => {
195    const done = await next(e)
196    if (!e.agentId) {
197      await follow($)
198    }
199
200    return done
201  }).catch(($, e, next) => next(e))
202
203  on('tool.call', { tool: ADD }, async ($, e) => {
204    if (e.agentId) {
205      return { result: 'Subagents do not record asks: put the question in your report to the session that dispatched you.' } as never
206    }
207    await follow($)
208    const input = e as unknown as { text?: string; recommendation?: string; from?: string }
209    const { ask, all } = await add($, input.text ?? '', input.recommendation ?? '', input.from ?? '')
210    const head = ask ? `Recorded as [${ask.id}].` : 'Nothing recorded: the text was empty.'
211
212    return { result: `${head}\n${listing(all)}` } as never
213  })
214
215  on('tool.call', { tool: RESOLVE }, async ($, e) => {
216    await follow($)
217    const input = e as unknown as { ids?: unknown }
218    const { gone, all } = await resolve($, idsOf(input.ids))
219    const head = gone.length > 0 ? `Resolved ${gone.map(id => `[${id}]`).join(' ')}.` : 'No open ask had those ids.'
220
221    return { result: `${head}\n${listing(all)}` } as never
222  })
223
224  on('tool.call', { tool: LIST }, async $ => {
225    await follow($)
226
227    return { result: listing(await read($, book)) } as never
228  })
229
230  on('command.run', { command: 'asks' }, async ($, e) => {
231    await follow($)
232    const [verb = '', ...rest] = e.args.trim().split(/\s+/)
233    if (verb === 'done' || verb === 'drop') {
234      const { gone, all } = await resolve($, idsOf(rest.join(' ')))
235      return { text: `${gone.length > 0 ? `Dropped ${gone.map(id => `[${id}]`).join(' ')}.` : 'No open ask had those ids.'}\n${listing(all)}` }
236    }
237    if (verb === 'clear') {
238      await change($, b => ({ ...b, asks: [] }))
239      return { text: 'Cleared every open ask.' }
240    }
241    if (verb === 'hide' || verb === 'show') {
242      await update($, isHidden, () => verb === 'hide')
243      return { text: verb === 'hide' ? 'The asks band is hidden. /asks show brings it back.' : 'The asks band is showing.' }
244    }
245
246    return { text: `${listing(await read($, book))}\n/asks done <ids> drops answered ones.` }
247  })
248
249  // Composes with any band beneath it (such as subagent-band's), so both show.
250  on('ui.render', { component: 'AbovePrompt' }, async ($, e, next) => {
251    const below = await next(e)
252    if (e.props.hasSurvey || (await read($, isHidden))) {
253      return below
254    }
255    const { asks } = await read($, book)
256    if (asks.length === 0) {
257      return below
258    }
259
260    const { Box, Text } = $.ui.resolve(e)
261    // Each ask takes two rows or more (a long question wraps); show the newest that fit and point at /asks for the rest.
262    const room = Math.max(1, Math.min(maxShown, Math.floor(((e.props.maxRows ?? 12) - 1) / 3)))
263    const shown = asks.slice(-room)
264    const hidden = asks.length - shown.length
265
266    return (
267      <Box flexDirection="column">
268        <Text key="head" bold color="yellow">{`Waiting on you (${asks.length})${hidden > 0 ? ` · ${hidden} older: /asks` : ''}`}</Text>
269        {shown.flatMap(ask => [
270          <Text key={`a${ask.id}`}>{line(ask)}</Text>,
271          ...(rec(ask) ? [<Text key={`r${ask.id}`} dimColor>{`    ${rec(ask)}`}</Text>] : []),
272        ])}
273        {below ?? null}
274      </Box>
275    )
276  })
277}
278

types/index.d.ts 23 lines

1/** One question or decision the session is waiting on from the person. */
2export type Ask = {
3  /** Small and stable for the session's life: what the band shows and what ask_resolve and /asks done take. */
4  id: number
5  /** The full question, with enough context to answer it without scrolling back. */
6  text: string
7  /** The recommended answer and its one-line reason; '' when there is none. Older saved entries lack it. */
8  recommendation: string
9  /** Who needs the answer: '' for this session, else the name of the agent whose question was relayed. */
10  from: string
11  /** Clock time in ms. */
12  addedAt: number
13}
14
15/** What the session keeps: the open asks and the next id. Saved to the plugin's store, one entry per session id. */
16export type Book = { asks: Ask[]; nextId: number }
17
18declare module 'claude-code' {
19  interface PluginState {
20    'open-asks': { book: Book; isHidden: boolean }
21  }
22}
23

Install

$claude plugin marketplace add erikdarlingdata/claude-plugins

$claude plugin install open-asks@erikdarling

Entry name may differ; see the README.

$claude plugin marketplace add https://www.slopshopper.com/community/marketplace.json

$claude plugin install open-asks@slopshopper-community

Points at the author's repo. Nothing re-hosted.

$git clone https://github.com/erikdarlingdata/claude-plugins

$claude --plugin-dir ./claude-plugins/plugins/open-asks

One session, nothing installed.

In the preview

adds /asks
gives Claude ask_add, ask_resolve, ask_list

Hooks

session.startprompt.composeprompt.submitturn.completetool.call{tool=mcp__open-asks__ask_add}tool.call{tool=mcp__open-asks__ask_resolve}tool.call{tool=mcp__open-asks__ask_list}command.run{command=asks}ui.render{component=AbovePrompt}

Reaches

$.clock.now (via addprune)$.command.register$.session.id$.state.get$.state.set$.store.delete (via prunesave)$.store.get (via followprune)$.store.keys$.store.set$.tool.register$.ui.resolve

Options

maxBandAsks: Most asks the band shows = 6
maxQuestionChars: Longest question or recommendation shown (characters) = 400
keepDays: Forget a session's unanswered asks after (days) = 30

Checks

validate: passed

Tests ✓ · State contract ✓ · first seen 2026-10-07

Darling Data — Claude Code plugins

Plugins

sqlserver-query-plans

GitHub Copilot CLI

Claude Code mods

subagent-fence

model-allowlist

seat-resume