@pmelab/gtd 36.0.0 → 38.0.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pmelab/gtd",
-  "version": "36.0.0",
+  "version": "38.0.0",
   "private": false,
   "description": "Git-aware CLI that emits the next prompt for an autonomous coding agent based on the current repository state",
   "bin": {

package/src/cli/Cli.test.ts

@@ -1106,6 +1106,7 @@ describe("standaloneKinds / needsOf", () => {
       "uncheck",
       "install",
       "loop",
+      "contextHook",
       "judgeRun",
       "strays",
     ])
@@ -1117,6 +1118,7 @@ describe("standaloneKinds / needsOf", () => {
     expect(needsOf("uncheck")).toBe("fs")
     expect(needsOf("install")).toBe("none")
     expect(needsOf("loop")).toBe("none")
+    expect(needsOf("contextHook")).toBe("none")
     expect(needsOf("judgeRun")).toBe("none")
     expect(needsOf("strays")).toBe("none")
     for (const kind of [
@@ -1202,19 +1204,24 @@ describe("renderHelp", () => {
 
   it("README.md and COMPATIBILITY.md list exactly the commands", () => {
     const commands = new Set(
-      [...renderHelp().matchAll(/^ {2}([a-z]+(?: [a-z]+)?)(?= )/gm)].map(([, name]) => name),
+      [...renderHelp().matchAll(/^ {2}([a-z]+(?:-[a-z]+)?(?: [a-z]+)?)(?= )/gm)].map(
+        ([, name]) => name,
+      ),
     )
     expect(commands).toContain("judge answer")
+    expect(commands).toContain("context-hook")
     const listed = (file: string, list: RegExp): Set<string> => {
       const doc = readFileSync(resolve(import.meta.dirname, file), "utf8")
       const match = doc.match(list)
       expect(match, file).not.toBeNull()
-      return new Set([...match![1]!.matchAll(/`([a-z]+(?: [a-z]+)?)`/g)].map(([, name]) => name!))
+      return new Set(
+        [...match![1]!.matchAll(/`([a-z]+(?:-[a-z]+)?(?: [a-z]+)?)`/g)].map(([, name]) => name!),
+      )
     }
     expect(
       listed("../../README.md", /The `gtd` bin's commands — ([\s\S]*?) — are\s+listed/),
     ).toEqual(commands)
-    expect(listed("../../COMPATIBILITY.md", /every command \(([\s\S]*?)\), option/)).toEqual(
+    expect(listed("../../COMPATIBILITY.md", /every command \(([\s\S]*?)\),\s+option/)).toEqual(
       commands,
     )
   })

package/src/cli/Cli.ts

@@ -35,7 +35,7 @@ import {
   type JsonMode,
 } from "./Program.js"
 import type { ToolCommands } from "./ToolCommands.js"
-import { EXIT_RUNTIME_ERROR, EXIT_USAGE_ERROR } from "../wire/index.js"
+import { EXIT_RUNTIME_ERROR, EXIT_USAGE_ERROR, parseContextWindow } from "../wire/index.js"
 
 export type { Command, CommandRequirements } from "./Program.js"
 export { needsOf, standaloneKinds } from "./Program.js"
@@ -90,6 +90,13 @@ const nonNegativeNumber = (raw: string, flag: string): Either.Either<number, str
   return Either.right(n)
 }
 
+const share = (raw: string, flag: string): Either.Either<number, string> => {
+  const n = Number(raw)
+  return raw.trim() !== "" && n > 0 && n <= 1
+    ? Either.right(n)
+    : Either.left(`gtd: ${flag} must be a share of the context window in (0, 1] — got "${raw}"`)
+}
+
 const FLAGS: readonly FlagRow[] = [
   {
     name: "--json",
@@ -245,6 +252,41 @@ const FLAGS: readonly FlagRow[] = [
       "GTD_JUDGE_MODEL, then judge.json, then sonnet",
     ],
   },
+  {
+    name: "--soft",
+    arity: 1,
+    repeatable: false,
+    scope: (kind) => kind === "contextHook",
+    decode: ([raw]) => share(raw ?? "", "--soft"),
+    scopeError: "gtd: --soft is only valid for `gtd context-hook`",
+    valueHint: "<share>",
+    help: ["(gtd context-hook only) the soft limit; default 0.6"],
+  },
+  {
+    name: "--hard",
+    arity: 1,
+    repeatable: false,
+    scope: (kind) => kind === "contextHook",
+    decode: ([raw]) => share(raw ?? "", "--hard"),
+    scopeError: "gtd: --hard is only valid for `gtd context-hook`",
+    valueHint: "<share>",
+    help: ["(gtd context-hook only) the hard limit; default 0.7"],
+  },
+  {
+    name: "--window",
+    arity: 1,
+    repeatable: false,
+    scope: (kind) => kind === "contextHook",
+    decode: ([raw]) => {
+      const window = parseContextWindow(raw)
+      return window !== undefined
+        ? Either.right(window)
+        : Either.left(`gtd: --window must be a positive integer — got "${raw ?? ""}"`)
+    },
+    scopeError: "gtd: --window is only valid for `gtd context-hook`",
+    valueHint: "<tokens>",
+    help: ["(gtd context-hook only) the model's context window in", "tokens; default 200000"],
+  },
   {
     name: "--slice",
     arity: 1,
@@ -593,6 +635,22 @@ const COMMAND_ROWS: readonly CommandRow[] = [
       "~/.config/gtd/loop.json); see docs/driver.md",
     ],
   },
+  {
+    token: "context-hook",
+    kind: "contextHook",
+    arity: "none",
+    details: [
+      "A Claude Code PostToolUse and PreCompact hook that stops an",
+      "agent turn at a share of its context window. Reads the",
+      "hook's input on stdin and the context the transcript's",
+      "latest assistant message used. Past --soft it blocks with a",
+      "request to end the turn with a handoff note; past --hard,",
+      "or at PreCompact, it stops the turn with a stopReason",
+      'starting "gtd: context limit". Prints nothing otherwise,',
+      "and for a subagent's tool call. Always exits 0 on valid",
+      "input; see docs/driver.md",
+    ],
+  },
   {
     token: "summary",
     kind: "summary",
@@ -1182,6 +1240,9 @@ export const parseArgv = (argv: readonly string[]): CliPlan => {
     readonly "--provider"?: "fixed" | "jev" | "llm"
     readonly "--answers"?: string
     readonly "--slice"?: string
+    readonly "--soft"?: number
+    readonly "--hard"?: number
+    readonly "--window"?: number
   }
 
   // `present.has("--json")` alone can't distinguish bare `--json` (no value
@@ -1285,6 +1346,20 @@ export const parseArgv = (argv: readonly string[]): CliPlan => {
     }
   }
 
+  if (kind === "contextHook") {
+    return {
+      kind: "command",
+      command: {
+        kind: "contextHook",
+        ...(bag["--soft"] !== undefined ? { soft: bag["--soft"] } : {}),
+        ...(bag["--hard"] !== undefined ? { hard: bag["--hard"] } : {}),
+        ...(bag["--window"] !== undefined ? { window: bag["--window"] } : {}),
+      },
+      json,
+      verbose,
+    }
+  }
+
   if (kind === "summary") {
     return {
       kind: "command",

package/src/cli/Program.test.ts

@@ -1686,6 +1686,7 @@ describe("runCommand — refuses in a repository with no commits", () => {
     uncheck: { kind: "uncheck", file: ".gtd/REVIEW.md" },
     install: { kind: "install" },
     loop: { kind: "loop" },
+    contextHook: { kind: "contextHook" },
     summary: { kind: "summary" },
     base: { kind: "base" },
     judge: { kind: "judge" },

package/src/cli/Program.ts

@@ -162,6 +162,12 @@ export type Command =
   | { readonly kind: "uncheck"; readonly file: string }
   | { readonly kind: "install" }
   | { readonly kind: "loop" }
+  | {
+      readonly kind: "contextHook"
+      readonly soft?: number
+      readonly hard?: number
+      readonly window?: number
+    }
   | { readonly kind: "summary"; readonly slice?: string }
   | { readonly kind: "base" }
   | { readonly kind: "judge" }
@@ -434,6 +440,24 @@ const readStdin = (): Effect.Effect<string, Error> =>
     catch: (e) => (e instanceof Error ? e : new Error(String(e))),
   })
 
+/** Stdout is written once: a hook reads one JSON document, or none. */
+const runContextHookCommand = (
+  command: Extract<Command, { kind: "contextHook" }>,
+  out: ArtifactOut,
+): Effect.Effect<void, Error, ToolCommands> =>
+  Effect.gen(function* () {
+    const tools = yield* ToolCommands
+    const input = yield* readStdin()
+    out.write(
+      yield* tools.contextHook({
+        input,
+        ...(command.soft !== undefined ? { soft: command.soft } : {}),
+        ...(command.hard !== undefined ? { hard: command.hard } : {}),
+        ...(command.window !== undefined ? { window: command.window } : {}),
+      }),
+    )
+  })
+
 /** Stdout is written once, after the answerer resolves — a rejection leaves it empty. */
 const runJudgeRunCommand = (
   command: Extract<Command, { kind: "judgeRun" }>,
@@ -1189,6 +1213,7 @@ export const needsOf = (kind: Command["kind"]): Needs => {
     case "lsp":
     case "install":
     case "loop":
+    case "contextHook":
     case "judgeRun":
     case "strays":
       return "none"
@@ -1207,6 +1232,7 @@ export const standaloneKinds = (): readonly Command["kind"][] => [
   "uncheck",
   "install",
   "loop",
+  "contextHook",
   "judgeRun",
   "strays",
 ]
@@ -1278,6 +1304,8 @@ const dispatchVoidCommand = (
       return runInstallCommand(out)
     case "loop":
       return runLoopCommand()
+    case "contextHook":
+      return runContextHookCommand(command, out)
     case "summary":
       return runSummaryCommand(out, command.slice)
     case "base":

package/src/cli/ToolCommands.ts

@@ -1,6 +1,7 @@
 import { Context } from "effect"
 import type { Effect } from "effect"
 import type { UiSettings } from "../flows/index.js"
+import type { ContextHookRequest } from "../wire/index.js"
 
 /** How to run THIS gtd — a driver (the loop, the LSP) never reads a different version's state than the one it ships with. */
 export type SelfGtd = readonly [string, ...string[]]
@@ -38,6 +39,8 @@ export class ToolCommands extends Context.Tag("ToolCommands")<
     ) => Effect.Effect<void, Error>
     readonly lsp: (gtd: SelfGtd) => Effect.Effect<void, Error>
     readonly loop: (gtd: SelfGtd) => Effect.Effect<void, Error>
+    /** The hook's stdout: a JSON document, or empty to let the turn go on. */
+    readonly contextHook: (request: ContextHookRequest) => Effect.Effect<string, Error>
     readonly judge: (request: JudgeRequest) => Promise<string>
   }
 >() {}

package/src/edge/Edge.ts

@@ -54,6 +54,7 @@ import {
   type ModelCost,
   type SliceEntry,
   type StepAccess,
+  type StepContextLimit,
 } from "../wire/index.js"
 
 import { GTD_VERSION } from "../install/index.js"
@@ -722,6 +723,13 @@ type RequestOf<K extends ReachedStep["request"]["kind"]> = Extract<
   { kind: K }
 >
 
+const stepContext = (
+  context: { readonly soft?: number | undefined; readonly hard?: number | undefined } | undefined,
+): StepContextLimit | undefined =>
+  context === undefined
+    ? undefined
+    : { ...optional("soft", context.soft), ...optional("hard", context.hard) }
+
 const promptDef = (
   common: StepCommon,
   request: RequestOf<"agent">,
@@ -735,6 +743,7 @@ const promptDef = (
   ...optional("system", request.options.system),
   ...optional("allowEmpty", request.options.allowEmpty),
   ...optional("keep", request.options.keep),
+  ...optional("context", stepContext(request.options.context)),
   ...optional("skills", skills),
   ...optional("access", access),
 })
@@ -850,6 +859,7 @@ export interface RestHints {
   readonly mode?: string
   readonly skills?: readonly string[]
   readonly access?: StepAccess
+  readonly context?: StepContextLimit
 }
 
 const hintsOf = (def: StepDef): RestHints => ({
@@ -861,6 +871,7 @@ const hintsOf = (def: StepDef): RestHints => ({
   ...optional("mode", def.mode),
   ...optional("skills", def.skills),
   ...optional("access", def.access),
+  ...optional("context", def.context),
 })
 
 const normalizeStatus = (raw: string): ChangeStatus => (raw === "A" ? "A" : raw === "D" ? "D" : "M")

package/src/flows/runtime.ts

@@ -16,9 +16,18 @@ export interface SteeringOptions {
   readonly base?: string | undefined
 }
 
+/** Shares of the model's context window at which a driver stops the turn — `gtd next --json`'s `context`. */
+export interface ContextLimitOptions {
+  /** Ask the agent to wrap up with a handoff note. Driver default 0.6. */
+  readonly soft?: number | undefined
+  /** Stop the turn outright. Driver default 0.7. */
+  readonly hard?: number | undefined
+}
+
 export interface AgentOptions extends SteeringOptions {
   readonly model?: string | undefined
   readonly system?: string | undefined
+  readonly context?: ContextLimitOptions | undefined
   /**
    * A turn that changes nothing completes the step. Without this an empty turn
    * is an attempt: recorded, but the process stays at the step (a stall).
@@ -115,6 +124,8 @@ export interface ScopeOptions {
   readonly model?: string | undefined
   /** The system prompt every agent step inside runs with, unless it sets its own. */
   readonly system?: string | undefined
+  /** The context limit every agent step inside runs with; a nested scope's or a step's own replaces it key by key. */
+  readonly context?: ContextLimitOptions | undefined
   /** The skill names every agent step inside declares — `gtd next --json`'s `skills`. A nested scope inherits it unless it sets its own. */
   readonly skills?: readonly string[] | undefined
   /** The file access every agent step inside runs with — `gtd next --json`'s `access`. A nested scope inherits it; its own replaces it wholesale. */

package/src/replay/Replay.ts

@@ -8,6 +8,7 @@ import {
   type ScopeAccess,
   type AccessDef,
   type ScopeOptions,
+  type ContextLimitOptions,
   type StepRequest,
   type Flow,
   type Mark,
@@ -21,7 +22,7 @@ import {
   unansweredQuestions,
 } from "../steering/index.js"
 import { accessShapeFault, foldAccess, sameAccess } from "./Access.js"
-import { globMatches } from "../wire/index.js"
+import { contextLimitFault, contextShapeFault, globMatches } from "../wire/index.js"
 import { refNameFault } from "./RefName.js"
 import { IMPLICIT_SLICE, SLICE_NAME, type SliceSpan } from "./Slices.js"
 import { diffTrees, isEmptyDiff, type TreeView } from "./Tree.js"
@@ -207,6 +208,28 @@ const budgeted = (
   return { evidence: bounded, truncated }
 }
 
+// The innermost of `chain`, named by its full path.
+const scopeLabel = (chain: readonly ScopeOptions[]): string => {
+  const path = chain.flatMap((o) => (o.name === undefined ? [] : [o.name])).join(".")
+  if (chain.at(-1)?.name !== undefined) return `scope "${path}"`
+  return path === "" ? "an unnamed scope" : `an unnamed scope inside "${path}"`
+}
+
+// Key by key, innermost last: a scope or step that sets only `hard` keeps the outer `soft`.
+const inheritedContext = (
+  layers: readonly (ContextLimitOptions | undefined)[],
+): ContextLimitOptions | undefined =>
+  layers.reduce<ContextLimitOptions | undefined>(
+    (merged, layer) =>
+      layer === undefined
+        ? merged
+        : {
+            ...merged,
+            ...Object.fromEntries(Object.entries(layer).filter(([, value]) => value !== undefined)),
+          },
+    undefined,
+  )
+
 interface Identity {
   readonly model: string | undefined
   readonly system: string | undefined
@@ -243,7 +266,7 @@ const STEERING_OPTIONS = ["file", "mode", "label", "base"]
 // The option keys each step accepts. A gtd.config.ts is evaluated without a
 // type check, so a misspelt key would otherwise be silently ignored.
 const KNOWN_OPTIONS: Readonly<Record<StepKind, ReadonlySet<string>>> = {
-  agent: new Set([...STEERING_OPTIONS, "model", "system", "allowEmpty", "keep"]),
+  agent: new Set([...STEERING_OPTIONS, "model", "system", "context", "allowEmpty", "keep"]),
   human: new Set([...STEERING_OPTIONS, "message", "acceptClean", "approve"]),
   run: new Set(STEERING_OPTIONS),
   judge: new Set([...STEERING_OPTIONS, "message"]),
@@ -426,11 +449,13 @@ export const replay = async (input: ReplayInput): Promise<ReplayOutcome> => {
         if (s.model !== undefined) persona.model = s.model
         if (s.system !== undefined) persona.system = s.system
       }
+      const context = inheritedContext([...scopes.map((s) => s.context), request.options.context])
       return {
         ...request,
         options: {
           ...persona,
           ...request.options,
+          ...(context === undefined ? {} : { context }),
         },
       }
     }
@@ -575,6 +600,28 @@ export const replay = async (input: ReplayInput): Promise<ReplayOutcome> => {
     return landPending(step, input.pending)
   }
 
+  // Each layer on its own first, so a bad scope or workflow option is named as
+  // such rather than blamed on the step it reached; then the merged limit.
+  const scopeContextFault = (): string | undefined => {
+    for (const [i, s] of scopes.entries()) {
+      const fault = s.context === undefined ? undefined : contextShapeFault(s.context)
+      if (fault !== undefined)
+        return `the context of ${scopeLabel(scopes.slice(0, i + 1))}: ${fault}`
+    }
+    return undefined
+  }
+
+  const resolvedContextFault = (
+    request: Extract<StepRequest, { kind: "agent" }>,
+  ): string | undefined => {
+    const own = request.options.context
+    const layered = scopeContextFault() ?? (own === undefined ? undefined : contextShapeFault(own))
+    if (layered !== undefined) return layered
+    const resolved = resolve(request)
+    const context = resolved.kind === "agent" ? resolved.options.context : undefined
+    return context === undefined ? undefined : contextLimitFault(context)
+  }
+
   // gtd.config.ts is loaded without a type check.
   const requestFault = (request: Exclude<StepRequest, { kind: "restart" }>): string | undefined => {
     if (request.kind === "run" && typeof request.body !== "string") {
@@ -582,6 +629,8 @@ export const replay = async (input: ReplayInput): Promise<ReplayOutcome> => {
     }
     if (request.kind !== "agent") return undefined
     const name = scoped(request.name)
+    const contextFault = resolvedContextFault(request)
+    if (contextFault !== undefined) return `gtd: step "${name}": ${contextFault}`
     if (request.options.keep === true) {
       // A clean allowEmpty keep would land an ordinary commit with no Gtd-Kept: a silent skip.
       if (request.options.allowEmpty === true) {

package/src/testkit/Layers.ts

@@ -206,6 +206,7 @@ const missingToolCommands: ToolCommands["Type"] = {
   ui: missingTool("ui"),
   lsp: missingTool("lsp"),
   loop: missingTool("loop"),
+  contextHook: missingTool("context-hook"),
   judge: () =>
     Promise.reject(
       new Error("gtd judge run: ToolCommands has no test double wired into testLayers()"),

package/src/testkit/steps.ts

@@ -26,6 +26,8 @@ export class TestkitWorld extends QuickPickleWorld {
   /** Per step, what its scripted actor does, in the order the scenario declared it. */
   actions = new Map<string, Actor[]>()
   verdicts = new Map<string, string>()
+  /** Per judge step, a verdict for each text its questions may contain; the first match answers. */
+  conditionalVerdicts = new Map<string, [text: string, verdict: string][]>()
   private created: TestRepo | undefined = undefined
 
   // The repository is created on first use and keeps the config and
@@ -79,6 +81,19 @@ export class TestkitWorld extends QuickPickleWorld {
       }
       actors[step] = () => verdict
     }
+    for (const [step, choices] of this.conditionalVerdicts) {
+      if (this.actions.has(step) || this.verdicts.has(step)) {
+        throw new Error(`step "${step}" has a conditional verdict and another script`)
+      }
+      // Matched against the pending questions, which `gtd judge` prints and the beat does not.
+      actors[step] = async (_, repo) => {
+        const { stdout } = await repo.gtd("judge")
+        const hit = choices.find(([text]) => stdout.includes(text))
+        if (hit === undefined)
+          throw new Error(`judge step "${step}" matched no verdict:\n${stdout}`)
+        return hit[1]
+      }
+    }
     await this.repo().drive(actors)
   }
 }
@@ -137,6 +152,16 @@ Given(
   },
 )
 
+// Lets one step write differently per visit, told apart by what it is prompted with.
+Given(
+  "step {string}, when prompted with {string}, writes {string} with:",
+  (world: TestkitWorld, step: string, text: string, path: string, content: string) => {
+    world.act(step, (beat, repo) => {
+      if (beat.content.includes(text)) repo.write(path, withNewline(content))
+    })
+  },
+)
+
 // A standing assertion like any queued action: it applies on every later visit
 // to the step until `from now on` clears the list.
 Given(
@@ -169,6 +194,16 @@ Given("judge step {string} answers:", (world: TestkitWorld, step: string, verdic
   world.verdicts.set(step, String(verdict))
 })
 
+Given(
+  "judge step {string}, when its questions contain {string}, answers:",
+  (world: TestkitWorld, step: string, text: string, verdict: string) => {
+    world.conditionalVerdicts.set(step, [
+      ...(world.conditionalVerdicts.get(step) ?? []),
+      [text, String(verdict)],
+    ])
+  },
+)
+
 When("gtd starts workflow {string}", async (world: TestkitWorld, workflow: string) => {
   await world.repo().start(workflow)
 })

package/src/wire/BeatDocument.ts

@@ -1,6 +1,14 @@
 import type { BeatKind, Demand, DemandSession } from "./Demand.js"
 import type { BeatStatus, NextMatch, StatusChange } from "./BeatStatus.js"
-import type { Actor, ApprovalEntry, ModelCost, StateMode, StateName, StepAccess } from "./types.js"
+import type {
+  Actor,
+  ApprovalEntry,
+  ModelCost,
+  StateMode,
+  StateName,
+  StepAccess,
+  StepContextLimit,
+} from "./types.js"
 import { WIRE_SCHEMA } from "./constants.js"
 
 /** `gtd next --json`'s `next` key — `null` when landing would commit nothing. */
@@ -56,6 +64,7 @@ export interface BeatDocument {
   readonly session: DemandSession | undefined
   readonly model: string | undefined
   readonly system: string | undefined
+  readonly context: StepContextLimit | undefined
   readonly validate: string | undefined
   readonly log: string
   readonly state: StateName
@@ -76,7 +85,7 @@ export interface BeatDocument {
 }
 
 /**
- * Flatten a `Demand` plus its `BeatStatus` into the single 25-key document
+ * Flatten a `Demand` plus its `BeatStatus` into the single 26-key document
  * `gtd next --json` emits — the ONLY place the two are joined. `cost`/
  * `costByModel` are omitted together, exactly when no cost was recorded
  * (`cost <= 0`).
@@ -93,6 +102,7 @@ export const beatDocument = (demand: Demand, status: BeatStatus): BeatDocument =
     session,
     model: status.model,
     system: status.system,
+    context: status.context,
     validate,
     log: status.log,
     state: status.state,

package/src/wire/BeatStatus.ts

@@ -5,6 +5,7 @@ import type {
   RenderedDemandSource,
   StateMode,
   StateName,
+  StepContextLimit,
 } from "./types.js"
 
 /** One pending change — `gtd next --json`'s `changes` entries. */
@@ -32,6 +33,7 @@ export interface BeatStatus {
   readonly initial: boolean
   readonly model: string | undefined
   readonly system: string | undefined
+  readonly context: StepContextLimit | undefined
   readonly log: string
   readonly state: StateName
   readonly actor: Actor
@@ -74,6 +76,7 @@ export const statusOf = (input: {
     initial,
     model: rendered.model,
     system: rendered.system !== undefined && rendered.system !== "" ? rendered.system : undefined,
+    context: rendered.context,
     log,
     state: rendered.state,
     actor: rendered.actor,

package/src/wire/ContextLimit.fixture.ts

@@ -0,0 +1,30 @@
+/** A Claude Code transcript whose latest assistant message used `tokens` of context, as the hook reads it from `transcript_path`. */
+export const transcriptAt = (tokens: number): string =>
+  [
+    { type: "user", message: { role: "user", content: "build it" } },
+    {
+      type: "assistant",
+      message: {
+        id: "msg_1",
+        role: "assistant",
+        usage: { input_tokens: 3, cache_read_input_tokens: 10, cache_creation_input_tokens: 7 },
+      },
+    },
+    { type: "user", message: { role: "user", content: [{ type: "tool_result" }] } },
+    {
+      type: "assistant",
+      message: {
+        id: "msg_2",
+        role: "assistant",
+        usage: {
+          input_tokens: 1,
+          cache_read_input_tokens: tokens - 1001,
+          cache_creation_input_tokens: 1000,
+          output_tokens: 500,
+        },
+      },
+    },
+    { type: "attachment", attachment: { type: "hook_success" } },
+  ]
+    .map((entry) => JSON.stringify(entry))
+    .join("\n") + "\n"