@nightlab-agent/subagent-spend 0.8.3 → 0.8.4

package/.claude-plugin/marketplace.json

@@ -8,7 +8,7 @@
       "name": "subagent-spend",
       "source": "./",
       "description": "A spend cap for interactive sessions, and per-subagent tokens, rate-limit windows, context fill, cost, steps, tool calls and tool errors of a Claude Code session, in a notice under the prompt, local files and panes (the usage pane not yet seen on a screen).",
-      "version": "0.8.3",
+      "version": "0.8.4",
       "category": "productivity"
     }
   ],

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "subagent-spend",
-  "version": "0.8.3",
+  "version": "0.8.4",
   "description": "A spend cap for interactive sessions, and per-subagent tokens, rate-limit windows, context fill, cost, steps, tool calls and tool errors of a Claude Code session, in a notice under the prompt, local files and panes (the usage pane not yet seen on a screen).",
   "author": {
     "name": "Nightlab"

package/CHANGELOG.md

@@ -2,6 +2,36 @@
 
 The form is Keep a Changelog; versions follow SemVer.
 
+## 0.8.4 - 2026-11-04
+- Lowering or changing `capUsd` now ends a cap set with `/spend-cap` for good. Before, changing the option away and
+  back brought the old `/spend-cap` figure back.
+- A measurement from before /clear no longer sets the new session's cost when its usage read fails. Before, the new
+  session could stop at the cap on the old session's cost. One gap stays: a measurement raised just before the engine's
+  reset whose read answers just after it still counts; `/spend-cap off` clears that.
+- Two overlapping measurements keep the newer one in the status line; the older could overwrite it.
+- A subagent step in the moment after /clear, while the engine still names the session left, no longer rewrites that
+  session's rows file with that one step.
+- The npm description fits the registry's 255 characters; it was cut in the middle of a word.
+- The 80 percent spend notice now also comes from the cost read before each step. A tool loop that crossed 80 percent
+  and reached the cap inside one turn got no notice: only a measurement could show it, and by the next one the cap was
+  already reached.
+- The "rows file not written" notice now stays in the status line after the subagent and usage figures until a write
+  lands or the session ends. It was replaced by the next main-loop step and never came back, and it took the place of
+  the subagent figures and pushed the cost toward the end of the line.
+- The by-hand script's status line rounds as the mod does: 12500 tokens read 12k there and 13k in the mod.
+- The Usage pane reads "resets in <1m" in a window's last minute; it read "resets in 0h 00m".
+- `/spend-cap` takes plain dollars only. `0x10` set a $16 cap and `1e2` a $100 cap; both are now refused, and so are
+  a leading `+` or a space after the `$`.
+- A rows write that fails during or after a `/clear` no longer puts the "rows file not written" notice on the new session, where
+  nothing would take it off.
+- A `/clear` while a subagent step redraws the pane no longer empties the rows file of the session it left.
+- A step that reads the cost while a session is ending no longer holds the new session at the old cost.
+- A cap set or lifted with `/spend-cap` now outlives a reload of the plugin; it went back to `capUsd`. A new `capUsd`
+  in `/config` still wins.
+- A late measurement no longer moves the status line's cost back below the figure the cap holds on.
+- A cost or measurement from the moment between a `/clear` and Claude Code's reset of its cost no longer lands on the
+  new session. It could hold that session at the old cost, or use up its 80 percent notice.
+
 ## 0.8.3 - 2026-11-03
 
 ### Fixed

package/README.md

@@ -141,7 +141,9 @@ For an interactive session, set `capUsd` in `/config` to a number of dollars.
 At 80 percent of it a notice says so, once. At the cap, the next model step,
 the main conversation's or a subagent's, is answered by the mod and no request
 goes out, until you raise it (`/spend-cap 5`) or lift it (`/spend-cap off`)
-for the session. `/spend-cap` alone shows the cap and the cost so far.
+for the session. What `/spend-cap` sets outlives a reload of the plugin;
+changing `capUsd` replaces it. `/spend-cap` alone shows the cap and the cost
+so far.
 
 ![Claude Code with a $0.10 cap: asked to read every file and describe each, Claude reads four files; the next step is answered by the mod's line saying the session cost $0.11 of the $0.10 cap and no request was sent](https://raw.githubusercontent.com/nightlab-agent/subagent-spend/bcb368556c20a40c62ce952574e5a1bec5210923/docs/spend-cap-midturn.png)
 
@@ -186,7 +188,8 @@ of consecutive main-conversation tool errors.
 
 **The status line** is one line for all three. Each part keeps its own
 piece, and the line shows the pieces that have a reading, in the order
-subagents, usage, turns. A part that is off, or has nothing yet, adds
+subagents, usage, turns, with the "rows file not written" notice between
+usage and turns when it is up. A part that is off, or has nothing yet, adds
 nothing. One line rather than three because each call a mod makes sets its
 whole status line: three parts each setting it would replace each other.
 
@@ -309,14 +312,14 @@ environment variable. Everything stays on your machine.
 
 | Hook | What it does | What it changes |
 |---|---|---|
-| `session.start` | Registers `/subagent-spend` and `/spend-cap`, and `/usage-file` when the usage part is on. | Nothing. |
+| `session.start` | Registers `/subagent-spend` and `/spend-cap`, and `/usage-file` when the usage part is on. After a reload, puts back what `/spend-cap` set. | Nothing. |
 | `command.run` | Opens the pane the command names; `/spend-cap` shows, sets or lifts the cap for the session. | Nothing. |
 | `ui.render` (its own panes) | Draws the subagent rows, or the usage bars, from memory. | Nothing. |
 | `agent.spawn` | Notes the subagent's type; opens the spend pane at the first one. | Nothing: the spawn goes on as asked, even if the mod fails. |
 | `tool.call` | Counts the call, and whether it came back as an error (turn counts). | Nothing: the call runs as asked and its result passes through. |
 | `session.measure` | Updates the usage figures, the status line and `latest.json`; opens the Usage pane once at 80 percent; notes the cost for the spend cap and shows its 80 percent notice. | Nothing: the event passes through untouched. |
-| `session.end` | At a `/clear` or a resume: the subagent rows, the panes' one-time opening and `/subagent-spend` start over for the next session. | Nothing: the event passes through untouched. |
-| `turn.step` | Main conversation: counts the step and rewrites the day file. Subagent: adds the step's tokens to its row and rewrites the rows file. | Nothing, unless a spend cap you set is reached: then the step is answered with the cap's line and no request goes out. |
+| `session.end` | At a `/clear` or a resume: the subagent rows, the panes' one-time opening, the cost the cap counts and `/subagent-spend` start over for the next session. | Nothing: the event passes through untouched. |
+| `turn.step` | With a spend cap: reads the cost before the step and shows the 80 percent notice if that read crossed it. Main conversation: counts the step and rewrites the day file. Subagent: adds the step's tokens to its row and rewrites the rows file. | Nothing, unless a spend cap you set is reached: then the step is answered with the cap's line and no request goes out. |
 
 ## What it does not do
 
@@ -328,11 +331,18 @@ history beyond the files it leaves, and it does not say which model a usage
 window is for; Claude Code reports the windows as the account's.
 
 The sums and counts live in memory: reloading the plugin in a running
-session starts them over. A folder that cannot be written is named once in
-the status line for the subagent rows, and passed over in silence for the
-other two; the session goes on. A subagent step whose response carried no
+session starts them over. A folder that cannot be written is named in the
+status line for the subagent rows, until a write lands or the session ends,
+and passed over in silence for the other two; the session goes on. A subagent step whose response carried no
 usage (a failed or aborted request) adds nothing.
 
+Around a `/clear`, Claude Code resets its cost a moment after the session
+ends. A cost read in that moment is left out, so the spend cap does not stop a
+step that starts then, even in a session already at the cap. A resume has the
+same moment and no such check: a cost read then counts for the session you
+resumed until a measurement or a later step passes it, and it can hold that
+session until you raise the cap.
+
 ## Remove it
 
 1. Uninstall the mod: `/plugin uninstall subagent-spend` at the Claude Code
@@ -376,7 +386,7 @@ session with `claude --plugin-dir .` from the clone, or set `CC_TYPES` to
 that file). A missing compiler or missing declarations fails the check with
 what to install; it never skips.
 
-That runs `claude plugin validate .`; `claude plugin test .`, 78 tests
+That runs `claude plugin validate .`; `claude plugin test .`, 142 tests
 through the test runner Claude Code ships for plugins, with a mocked file
 system and mocked Claude Code events (the tests of the three former mods, one per
 option turned off, and tests where events finish out of order, arrive two at

package/hooks/cap.ts

@@ -14,9 +14,13 @@ export const cap = {
   warned: false,
 }
 
+/** Dollars as a person writes them: `5`, `2.50`, `$4`, `.5`. Number() alone also reads `0x10` as 16 and `1e2` as 100. */
+const DOLLARS = /^\$?(\d+(\.\d*)?|\.\d+)$/
+
 /** The option's value as a cap: a positive number of dollars, anything else off. */
 export function capOf(v: unknown): number | null {
-  const n = typeof v === 'number' ? v : typeof v === 'string' && v.trim() !== '' ? Number(v.trim().replace(/^\$/, '')) : NaN
+  const text = typeof v === 'string' ? v.trim() : ''
+  const n = typeof v === 'number' ? v : DOLLARS.test(text) ? Number(text.replace(/^\$/, '')) : NaN
   return Number.isFinite(n) && n > 0 ? n : null
 }
 

package/hooks/panes.tsx

@@ -0,0 +1,62 @@
+import { atom, read } from 'claude-code'
+import type { Register } from 'claude-code'
+
+import type { Row, Shown } from '../types'
+import { count, fmt, paneLines } from './spend'
+import { OPEN_AT, bar, usageLines } from './usage'
+
+export const SPEND_PANE = 'subagent-spend'
+export const USAGE_PANE = 'usage-file'
+
+// What the panes draw: the same atoms as hooks/register.tsx. Change a tag in both files.
+const shownRows = atom({ plugin: 'subagent-spend', key: 'rows' } as const, [] as Row[], { shape: 'rows-2' })
+const shownUsage = atom({ plugin: 'subagent-spend', key: 'latest' } as const, null as Shown | null, { shape: 'latest-1' })
+
+/** The two panes. With the usage part off, its pane passes on. */
+export const registerPanes = (on: Parameters<Register>[0], usageOn: boolean) => {
+  on('ui.render', { component: 'Pane', requestId: SPEND_PANE }, async ($, e) => {
+    const { Box, Text } = $.ui.resolve(e)
+    const list = await read($, shownRows)
+    const room = Math.max(1, (e.viewport?.rows ?? 24) - 4)
+    let tok = 0
+    for (const r of list) tok += r.total
+    return (
+      <Box flexDirection="column">
+        <Text bold>
+          {count(list.length, 'subagent')}, {fmt(tok)} tokens
+        </Text>
+        {list.length === 0 && <Text dimColor>No subagent has run in this session yet.</Text>}
+        {paneLines(list)
+          .slice(0, room)
+          .map(line => (
+            <Text>{line}</Text>
+          ))}
+      </Box>
+    )
+  })
+
+  on('ui.render', { component: 'Pane', requestId: USAGE_PANE }, async ($, e, next) => {
+    if (!usageOn) return next(e)
+    const { Box, Text } = $.ui.resolve(e)
+    const s = await read($, shownUsage)
+    if (!s) {
+      return (
+        <Box flexDirection="column">
+          <Text dimColor>No measurement yet in this session.</Text>
+        </Box>
+      )
+    }
+    const now = new Date()
+    return (
+      <Box flexDirection="column">
+        {s.windows.length === 0 && <Text dimColor>No rate-limit windows (not on a subscription).</Text>}
+        {usageLines(s, now).map((line, i) => (
+          <Text color={s.windows[i]!.percentUsed >= OPEN_AT ? 'red' : undefined}>{line}</Text>
+        ))}
+        {s.context !== null && <Text>{`Context     ${bar(s.context)}  ${s.context}%`}</Text>}
+        {s.usd !== null && <Text>{`Cost        $${s.usd.toFixed(2)}`}</Text>}
+        <Text dimColor>{`measured ${s.at.slice(11, 19)} UTC`}</Text>
+      </Box>
+    )
+  })
+}

package/hooks/register.tsx

@@ -1,11 +1,14 @@
 import { atom, read, update } from 'claude-code'
-import type { EngineInterface, Register, SessionMeasureInput } from 'claude-code'
+import type { EngineInterface, Register, SessionMeasureInput, SessionUsage } from 'claude-code'
 
-import type { Row, Shown } from '../types'
+import type { HeldCap, Row, Shown } from '../types'
 import { addStep, count, fmt, latest, nextStep, rowsText, paneLines, rows, spendStatus, types } from './spend'
 import { countCall, localDay, tally, tallyText, turnsStatus } from './turns'
 import { cap, capCommand, capOf, heldText, reached, warnNow } from './cap'
-import { OPEN_AT, bar, fileText, shownOf, shownStatus, usageLines, usageStatus } from './usage'
+import { OPEN_AT, fileText, shownOf, shownStatus, usageStatus } from './usage'
+import { SPEND_PANE, USAGE_PANE, registerPanes } from './panes'
+import { out, writeLatest } from './write'
+import type { Out } from './write'
 
 // subagent-spend, the hooks module: a session's meters in one mod.
 //
@@ -23,25 +26,26 @@ import { OPEN_AT, bar, fileText, shownOf, shownStatus, usageLines, usageStatus }
 //
 // One status line: three mods each setting the whole line would overwrite each other, so
 // each part keeps its own piece and the line shows the pieces that have a reading, in the
-// order spend | usage | turns.
+// order spend | usage | notice | turns.
 //
 // - cap (option `capUsd`, off by default): at the cap the next model step is answered by the
 //   mod with no request made (./cap.ts).
 //
 // DESIGN NOTE, deliberately narrow: apart from the cap the user sets, it never denies, never rewrites a
 // request or an event, reads only the events the engine hands it and sends nothing off the machine. A failed
-// write is swallowed (the spend part names it once in the status line): the files are
+// write is swallowed (a failed rows write is named in the status line until a write lands): the files are
 // advisory, and a gauge that stops the engine would be worse than no gauge.
 
-const SPEND_PANE = 'subagent-spend'
 const SPEND_TITLE = 'Subagent spend'
-const USAGE_PANE = 'usage-file'
 const USAGE_TITLE = 'Usage'
 
-// What the panes draw; the module's own Map stays the rows file's source. Change a tag
-// when its type's fields change: it declines what an earlier version stored.
+// What the panes draw (the same plugin, key and shape in hooks/panes.tsx: the engine's scan reads each file's own
+// atoms); the module's own Map stays the rows file's source. Change a tag, in both files, when its type's fields change:
+// it declines what an earlier version stored.
 const shownRows = atom({ plugin: 'subagent-spend', key: 'rows' } as const, [] as Row[], { shape: 'rows-2' })
 const shownUsage = atom({ plugin: 'subagent-spend', key: 'latest' } as const, null as Shown | null, { shape: 'latest-1' })
+// `/spend-cap`'s last word, held by the host: a reload starts these modules over and runs `register` from the options alone.
+const heldCap = atom({ plugin: 'subagent-spend', key: 'cap' } as const, null as HeldCap | null, { shape: 'cap-1' })
 
 let spendOpened = false
 let usageOpened = false
@@ -54,6 +58,9 @@ let rowsSession: string | null = null
 let asks = 0
 let switchedAt = 0
 let leftSession: string | null = null
+// The session left at a /clear, until the next end says otherwise: the engine may go on naming it for a moment after
+// session.end, and a step in that moment would rewrite its closed rows file with that step alone. Only a resume comes back to it.
+let cleared: string | null = null
 
 function startOver(left: string | null) {
   leftSession = left
@@ -74,57 +81,18 @@ async function sessionNow($: EngineInterface) {
   } catch {
     // no session id on this host
   }
-  if (mine <= switchedAt && id === leftSession) return null
+  if (id === cleared || (mine <= switchedAt && id === leftSession)) return null
   if (rowsSession !== null && id !== rowsSession) startOver(rowsSession)
   rowsSession = id
   return id
 }
 
-/** One file of one part in this session: whether a write is in flight, whether one is owed, whether
- * `<dir>/.gitignore` is left alone (a folder not of the mod's own name) or was written, and the newest content to write. */
-type Out = { writing: boolean; owed: boolean; ignore: boolean; ignored: boolean; newest: { name: string; text: () => string } | null }
-const out = (own: boolean): Out => ({ writing: false, owed: false, ignore: !own, ignored: false, newest: null })
-
-/** One write at a time per file, always from the newest content. Two events can wait at once (on
- * `$.session.id()` or on a write); if the earlier one's write landed last, its older figures would sit on
- * top of the newer ones. An event that finds a write in flight marks the file as owed and goes on; the
- * writing one writes again, from the newest content, until nothing is owed. A failed write is made up
- * by the next event. Before each write, when it is missing: `<dir>/.gitignore` holding `*`, so git
- * ignores the folder in every project with no step from the user. */
-async function writeLatest($: EngineInterface, dir: string, f: Out) {
-  if (f.writing) {
-    f.owed = true
-    return
-  }
-  f.writing = true
-  try {
-    do {
-      f.owed = false
-      if (!f.ignore) {
-        // checked before every write, not once: a user who deletes the folder mid-session gets it back ignored
-        let has = f.ignored
-        try {
-          has = await $.fs.exists(`${dir}/.gitignore`)
-        } catch {
-          // a host that cannot answer: once per session, as before
-        }
-        if (!has) await $.fs.write(`${dir}/.gitignore`, '*\n')
-        f.ignored = true
-      }
-      const n = f.newest
-      if (n) await $.fs.write(`${dir}/${n.name}`, n.text())
-    } while (f.owed)
-  } finally {
-    f.writing = false
-  }
-}
-
 /** Each part's piece of the status line; undefined until that part has a reading. */
-type Parts = { usage?: string; turns?: string; spend?: string }
+type Parts = { usage?: string; turns?: string; spend?: string; notice?: string }
 
-/** The one status line: the pieces that have a reading, spend | usage | turns (spend first: a narrow window cuts the end). */
+/** The one status line: the pieces that have a reading, spend | usage | notice | turns (the figures first: a narrow window cuts the end). */
 function showStatus($: EngineInterface, parts: Parts) {
-  const line = [parts.spend, parts.usage, parts.turns].filter(Boolean).join(' | ')
+  const line = [parts.spend, parts.usage, parts.notice, parts.turns].filter(Boolean).join(' | ')
   try {
     $.ui.status(line || undefined)
   } catch {
@@ -132,9 +100,21 @@ function showStatus($: EngineInterface, parts: Parts) {
   }
 }
 
+/** The cap's 80 percent notice, when one is due. */
+function showWarning($: EngineInterface) {
+  const warning = warnNow()
+  if (!warning) return
+  try {
+    $.ui.toast(warning)
+  } catch {
+    // a surface with no toasts: the cap still holds
+  }
+}
+
 export const register: Register = (on, options) => {
   const usageOn = options.usageFile !== false
-  cap.usd = capOf(options.capUsd)
+  const capOption = capOf(options.capUsd)
+  cap.usd = capOption
   cap.spent = null
   cap.warned = false
   const turnsOn = options.turnTally !== false
@@ -146,7 +126,6 @@ export const register: Register = (on, options) => {
   const own = (dir: string, name: string) => dir.replace(/[\\/]+$/, '').split(/[\\/]/).at(-1) === name
   const files = { spend: out(own(spendDir, '.subagent-spend')), usage: out(own(usageDir, '.usage-file')), turns: out(own(turnsDir, '.turn-tally')) }
   const parts: Parts = {}
-  let spendWarned = false
   // Numbers each measurement in the order the engine raised them; latest.json is written from the newest.
   let seq = 0
   /** The last measurement, whose windows and context the status line keeps between measurements. */
@@ -155,8 +134,29 @@ export const register: Register = (on, options) => {
   // reading is the newest: a read that answers late with a lower figure never brings it back. Each
   // session end starts a new count, and a read still out for the session left is dropped.
   let costSession = 0
+  // A /clear can reset the cost ledger after session.end is over (seen in the 2.1.312 bundle; the declarations name no
+  // order), and a step or measurement can land between. Cost and start reset together (SessionUsage.startedAt: what the figures count from), so a reading
+  // with the left session's start is the left session's. A fork or resume may keep that start: only a /clear sets this.
+  let leftStart: number | null = null
+  /** Whether a usage read made while `costSession` stood at `session` belongs to a session already left. */
+  const ofLeft = (session: number, usage: SessionUsage) => session !== costSession || usage.startedAt === leftStart
+  /** The next cost reading is the new session's; the cap the user set stays. */
+  const startCost = () => {
+    cap.spent = null
+    cap.warned = false
+    costSession++
+  }
 
   on('session.start', async ($, e, next) => {
+    try {
+      // fires again at a reload; a cap set over another option gives way to the new one
+      const held = await read($, heldCap)
+      if (held?.option === capOption) cap.usd = held.usd
+      // the new option replaced it for good: changing back brings the option, not this
+      else if (held) await update($, heldCap, () => null)
+    } catch {
+      // nothing held on this surface: the option stands
+    }
     try {
       await $.command.register({ name: 'subagent-spend', description: 'Show what each subagent of this session costs, in a pane' })
       await $.command.register({ name: 'spend-cap', description: 'Show, set (/spend-cap 5) or lift (/spend-cap off) the spend cap of this session' })
@@ -167,7 +167,15 @@ export const register: Register = (on, options) => {
     return next(e)
   })
 
-  on('command.run', { command: 'spend-cap' }, async (_, e) => ({ text: capCommand(e.args ?? '') }))
+  on('command.run', { command: 'spend-cap' }, async ($, e) => {
+    const text = capCommand(e.args ?? '')
+    try {
+      await update($, heldCap, () => ({ usd: cap.usd, option: capOption }))
+    } catch {
+      // the cap holds in memory; only a reload would lose it
+    }
+    return { text }
+  })
 
   on('command.run', { command: 'subagent-spend' }, async $ => {
     await $.ui.open({ id: SPEND_PANE, title: SPEND_TITLE })
@@ -181,51 +189,7 @@ export const register: Register = (on, options) => {
     return { text: `Usage pane opened. ${s ? shownStatus(s) : 'No measurement yet in this session.'}` }
   })
 
-  on('ui.render', { component: 'Pane', requestId: SPEND_PANE }, async ($, e) => {
-    const { Box, Text } = $.ui.resolve(e)
-    const list = await read($, shownRows)
-    const room = Math.max(1, (e.viewport?.rows ?? 24) - 4)
-    let tok = 0
-    for (const r of list) tok += r.total
-    return (
-      <Box flexDirection="column">
-        <Text bold>
-          {count(list.length, 'subagent')}, {fmt(tok)} tokens
-        </Text>
-        {list.length === 0 && <Text dimColor>No subagent has run in this session yet.</Text>}
-        {paneLines(list)
-          .slice(0, room)
-          .map(line => (
-            <Text>{line}</Text>
-          ))}
-      </Box>
-    )
-  })
-
-  on('ui.render', { component: 'Pane', requestId: USAGE_PANE }, async ($, e, next) => {
-    if (!usageOn) return next(e)
-    const { Box, Text } = $.ui.resolve(e)
-    const s = await read($, shownUsage)
-    if (!s) {
-      return (
-        <Box flexDirection="column">
-          <Text dimColor>No measurement yet in this session.</Text>
-        </Box>
-      )
-    }
-    const now = new Date()
-    return (
-      <Box flexDirection="column">
-        {s.windows.length === 0 && <Text dimColor>No rate-limit windows (not on a subscription).</Text>}
-        {usageLines(s, now).map((line, i) => (
-          <Text color={s.windows[i]!.percentUsed >= OPEN_AT ? 'red' : undefined}>{line}</Text>
-        ))}
-        {s.context !== null && <Text>{`Context     ${bar(s.context)}  ${s.context}%`}</Text>}
-        {s.usd !== null && <Text>{`Cost        $${s.usd.toFixed(2)}`}</Text>}
-        <Text dimColor>{`measured ${s.at.slice(11, 19)} UTC`}</Text>
-      </Box>
-    )
-  })
+  registerPanes(on, usageOn)
 
   on('agent.spawn', async ($, e, next) => {
     const started = await next(e)
@@ -247,11 +211,27 @@ export const register: Register = (on, options) => {
 
   on('session.end', async ($, e, next) => {
     startOver(e.sessionId)
-    // the next session's first measurement brings its own cost; the cap the user set stays
-    cap.spent = null
-    cap.warned = false
-    costSession++
+    cleared = e.reason === 'clear' && e.sessionId ? e.sessionId : null
+    const held = cap.spent
+    startCost()
+    // a key outlives no end: a resume may come back to the session it names
+    leftStart = null
+    if (e.reason === 'clear') {
+      // asked before the end step, not waited for: this chain shares one short bound. No answer, no key: a cost read
+      // before the ledger's reset then counts for the new session
+      const asked = costSession
+      try {
+        $.session.usage().then(u => {
+          const usd = u.cost?.usd ?? 0
+          // an answer after the end step, or a figure below the one held, may be of a ledger already reset
+          if (asked === costSession && usd > 0 && usd >= (held ?? 0)) leftStart = u.startedAt ?? null
+        }, () => undefined)
+      } catch {
+        // no answer, no key
+      }
+    }
     parts.spend = undefined
+    parts.notice = undefined
     // cost and context belong to the session left: the panes and the line wait for the new one's first reading
     parts.usage = undefined
     measured = undefined
@@ -262,24 +242,40 @@ export const register: Register = (on, options) => {
     } catch {
       // the panes miss one redraw; the next step or measurement draws them
     }
-    return next(e)
+    try {
+      return await next(e)
+    } finally {
+      // a step can read the old cost, or fail a write, while the end step runs; both go with the session too
+      startCost()
+      parts.notice = undefined
+      showStatus($, parts)
+    }
   })
 
   on('session.measure', async ($, e, next) => {
-    if (e.cost) cap.spent = Math.max(cap.spent ?? 0, e.cost.usd)
-    const warning = warnNow()
-    if (warning) {
+    // numbered before any wait: two at once keep the order the engine raised them in
+    const mine = ++seq
+    if (leftStart !== null) {
+      // a measurement carries no start, so it asks
+      const session = costSession
+      let left = false
       try {
-        $.ui.toast(warning)
+        left = ofLeft(session, await $.session.usage())
       } catch {
-        // a surface with no toasts: the cap still holds
+        // no answer: the measurement stands, unless /clear came during the read
+        left = session !== costSession
       }
+      if (left) return next(e)
     }
+    if (e.cost) cap.spent = Math.max(cap.spent ?? 0, e.cost.usd)
+    showWarning($)
     if (!usageOn) return next(e)
-    const mine = ++seq
-    measured = e
-    parts.usage = usageStatus(e)
-    showStatus($, parts)
+    if (mine === seq) {
+      measured = e
+      // the highest reading, as the cap: a measurement can land after a read that went past it
+      parts.usage = usageStatus(e, e.cost ? (cap.spent ?? undefined) : undefined)
+      showStatus($, parts)
+    }
     try {
       // a newer measurement already shown keeps the pane; this one's figures are behind it
       await update($, shownUsage, s => (mine !== seq ? s : shownOf(e, new Date())))
@@ -314,7 +310,7 @@ export const register: Register = (on, options) => {
       const session = costSession
       try {
         const usage = await $.session.usage()
-        const usd = session === costSession ? usage.cost?.usd : undefined
+        const usd = ofLeft(session, usage) ? undefined : usage.cost?.usd
         if (usd !== undefined && usd >= (cap.spent ?? 0)) cap.spent = usd
         if (usd !== undefined && usd === cap.spent && usageOn && measured) {
           // the line's dollar figure is the one the cap holds on, not the last turn's
@@ -324,6 +320,7 @@ export const register: Register = (on, options) => {
       } catch {
         // no cost here: the last measurement stands
       }
+      showWarning($)
     }
     if (reached()) {
       // answered here, no request made: the turn (or the subagent) ends on this text
@@ -356,6 +353,10 @@ export const register: Register = (on, options) => {
     // a step whose id came back after its session ended: its rows file is closed
     if (sessionId === null) return response
     addStep(agentId, sessionId, response.usage, e.model, new Date(), order)
+    // the file's content and session are taken now, before any wait: a /clear during one empties the Map
+    const writing = costSession
+    const text = rowsText()
+    files.spend.newest = { name: `${sessionId || 'no-session'}.jsonl`, text: () => text }
     try {
       await update($, shownRows, () => [...rows.values()])
     } catch {
@@ -364,20 +365,16 @@ export const register: Register = (on, options) => {
     parts.spend = spendStatus()
     showStatus($, parts)
     try {
-      // the text is taken now, not at the write: a /clear while a write waits empties the Map it reads
-      const text = rowsText()
-      files.spend.newest = { name: `${sessionId || 'no-session'}.jsonl`, text: () => text }
-      await writeLatest($, spendDir, files.spend)
-    } catch (err) {
-      // unwritable folder: say so once, then the session goes on
-      if (!spendWarned) {
-        spendWarned = true
-        try {
-          $.ui.status(`subagent-spend: rows file not written (${err instanceof Error ? err.message : String(err)})`)
-        } catch {
-          // nothing left to tell it on
-        }
+      if ((await writeLatest($, spendDir, files.spend)) && parts.notice) {
+        parts.notice = undefined
+        showStatus($, parts)
       }
+    } catch (err) {
+      // a write of the session left: on the new session nothing would take its notice off
+      if (writing !== costSession) return response
+      // unwritable folder: the line says so until a write lands, and the session goes on
+      parts.notice = `subagent-spend: rows file not written (${err instanceof Error ? err.message : String(err)})`
+      showStatus($, parts)
     }
     return response
   })

package/hooks/usage.ts

@@ -19,13 +19,14 @@ export const bar = (pct: number) => {
   return '█'.repeat(full) + '░'.repeat(10 - full)
 }
 
-/** Time left to a reset: `2h 05m`, `3d 4h`, `now`; empty when the engine gave no reset time. */
+/** Time left to a reset: `2h 05m`, `3d 4h`, `<1m`, `now`; empty when the engine gave no reset time. */
 export const untilText = (resetsAt: string | null, now: Date) => {
   if (!resetsAt) return ''
   const ms = Date.parse(resetsAt) - now.getTime()
   if (Number.isNaN(ms)) return ''
   if (ms <= 0) return 'now'
   const min = Math.floor(ms / 60000)
+  if (min === 0) return '<1m'
   if (min >= 2880) return `${Math.floor(min / 1440)}d ${Math.floor((min % 1440) / 60)}h`
   return `${Math.floor(min / 60)}h ${String(min % 60).padStart(2, '0')}m`
 }

package/hooks/write.ts

@@ -0,0 +1,44 @@
+import type { EngineInterface } from 'claude-code'
+
+// The files the mod keeps: one writer per file, from the newest content.
+
+/** One file of one part in this session: whether a write is in flight, whether one is owed, whether
+ * `<dir>/.gitignore` is left alone (a folder not of the mod's own name) or was written, and the newest content to write. */
+export type Out = { writing: boolean; owed: boolean; ignore: boolean; ignored: boolean; newest: { name: string; text: () => string } | null }
+export const out = (own: boolean): Out => ({ writing: false, owed: false, ignore: !own, ignored: false, newest: null })
+
+/** One write at a time per file, always from the newest content. Two events can wait at once (on
+ * `$.session.id()` or on a write); if the earlier one's write landed last, its older figures would sit on
+ * top of the newer ones. An event that finds a write in flight marks the file as owed and goes on; the
+ * writing one writes again, from the newest content, until nothing is owed. A failed write is made up
+ * by the next event. Before each write, when it is missing: `<dir>/.gitignore` holding `*`, so git
+ * ignores the folder in every project with no step from the user. True when this call wrote; false when
+ * it left the file to the write in flight, whose result is not known yet. */
+export async function writeLatest($: EngineInterface, dir: string, f: Out) {
+  if (f.writing) {
+    f.owed = true
+    return false
+  }
+  f.writing = true
+  try {
+    do {
+      f.owed = false
+      if (!f.ignore) {
+        // checked before every write, not once: a user who deletes the folder mid-session gets it back ignored
+        let has = f.ignored
+        try {
+          has = await $.fs.exists(`${dir}/.gitignore`)
+        } catch {
+          // a host that cannot answer: once per session, as before
+        }
+        if (!has) await $.fs.write(`${dir}/.gitignore`, '*\n')
+        f.ignored = true
+      }
+      const n = f.newest
+      if (n) await $.fs.write(`${dir}/${n.name}`, n.text())
+    } while (f.owed)
+    return true
+  } finally {
+    f.writing = false
+  }
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@nightlab-agent/subagent-spend",
-  "version": "0.8.3",
-  "description": "Claude Code plugin: a spend cap for interactive sessions, and per-subagent tokens, rate-limit windows, context fill, cost, steps, tool calls and tool errors of a session, in a notice under the prompt, local files and panes (the usage pane not yet seen on a screen).",
+  "version": "0.8.4",
+  "description": "Claude Code plugin: a spend cap for interactive sessions, and per-subagent tokens, rate-limit windows, context fill, cost, steps, tool calls and tool errors, in a notice under the prompt, local files and panes (the usage pane not yet seen on a screen).",
   "keywords": [
     "claude-code",
     "claude-code-mod",
@@ -30,6 +30,8 @@
     "hooks/spend.ts",
     "hooks/turns.ts",
     "hooks/usage.ts",
+    "hooks/panes.tsx",
+    "hooks/write.ts",
     "types/",
     "kit/",
     "subagent_spend.py",

package/subagent_spend.py

@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-"""subagent-spend 0.8.3: attribute Claude Code token usage to each subagent.
+"""subagent-spend 0.8.4: attribute Claude Code token usage to each subagent.
 
   subagent_spend.py hook        SubagentStop hook: reads the hook JSON on stdin, sums the usage
                                 in the subagent transcript, appends one line to the session's rows file.
@@ -65,7 +65,7 @@ def rows_for(session_id):
         if isinstance(j, dict) and "total" in j: byid[j.get("agent_id") or f"row{n}"] = j
     return list(byid.values())
 
-def fmt(n): return f"{n/1000:.0f}k" if n >= 10000 else str(n)
+def fmt(n): return f"{(n + 500) // 1000}k" if n >= 10000 else str(n)  # a half goes up, as Math.round does in hooks/spend.ts
 
 def statusline():
     try:

package/types/index.d.ts

@@ -22,8 +22,11 @@ export type Shown = {
   usd: number | null
 }
 
+/** What /spend-cap last left, and the `capUsd` option in force then. */
+export type HeldCap = { usd: number | null; option: number | null }
+
 declare module 'claude-code' {
   interface PluginState {
-    'subagent-spend': { rows: Shaped<Row[]>; latest: Shaped<Shown | null> }
+    'subagent-spend': { rows: Shaped<Row[]>; latest: Shaped<Shown | null>; cap: Shaped<HeldCap | null> }
   }
 }