@pmelab/gtd 24.0.0 → 24.2.0

package/src/wire/BeatDocument.test.ts

@@ -0,0 +1,419 @@
+import { describe, expect, it } from "vitest"
+import { beatDocument, renderBeatJson } from "./BeatDocument.js"
+import {
+  BEAT_KINDS,
+  demandOf,
+  stallDiagnosis,
+  type BeatKind,
+  statusOf,
+  type NextMatch,
+  type StatusChange,
+  DEMAND_BRIEFING,
+  renderBeatPlain,
+  type ModelCost,
+  type RenderedDemandSource,
+  WIRE_SCHEMA,
+} from "./index.js"
+
+const rendered = (overrides: Partial<RenderedDemandSource> = {}): RenderedDemandSource => ({
+  state: "build.fixing",
+  actor: "agent",
+  content: "fix it",
+  ...overrides,
+})
+
+interface DocumentInput {
+  readonly rendered?: RenderedDemandSource
+  readonly kind: BeatKind
+  readonly idle?: boolean
+  readonly initial?: boolean
+  readonly log?: string
+  readonly session?: { readonly id: string; readonly resume: boolean }
+  readonly validate?: string
+  readonly changes?: readonly StatusChange[]
+  readonly next?: NextMatch | null
+  readonly cost?: number
+  readonly costByModel?: readonly ModelCost[]
+}
+
+/** `demandOf`'s own input, isolated so `documentFor` stays a flat two-call body — `session`/`validate` are only spread in when the caller actually passed one, since `demandOf`'s `prompt` variant forbids an explicit `undefined`. */
+const demandInput = (
+  input: DocumentInput,
+  r: RenderedDemandSource,
+): Parameters<typeof demandOf>[0] => ({
+  rendered: r,
+  kind: input.kind,
+  ...(input.session !== undefined ? { session: input.session } : {}),
+  ...(input.validate !== undefined ? { validate: input.validate } : {}),
+})
+
+/** `statusOf`'s own input, isolated for the same reason as `demandInput` above. */
+const statusInput = (
+  input: DocumentInput,
+  r: RenderedDemandSource,
+): Parameters<typeof statusOf>[0] => ({
+  rendered: r,
+  idle: input.idle ?? false,
+  initial: input.initial ?? false,
+  workflow: "feature",
+  log: input.log ?? "log",
+  changes: input.changes ?? [],
+  next: input.next ?? null,
+  cost: input.cost ?? 0,
+  costByModel: input.costByModel ?? [],
+})
+
+/** Builds one full `BeatDocument` in one call, mirroring the pre-split `beatFields` call shape so every golden below reads the same as before this package. */
+const documentFor = (input: DocumentInput) => {
+  const r = input.rendered ?? rendered()
+  return beatDocument(demandOf(demandInput(input, r)), statusOf(statusInput(input, r)))
+}
+
+const renderJsonLine = (input: Parameters<typeof documentFor>[0]): string =>
+  renderBeatJson(documentFor(input))
+
+describe("beatDocument / renderBeatJson", () => {
+  it("emits the unconditional fields plus the resolved kind and content", () => {
+    const line = renderJsonLine({ rendered: rendered(), kind: "script", log: ".git/gtd-loop.log" })
+    expect(JSON.parse(line)).toEqual({
+      schema: WIRE_SCHEMA,
+      kind: "script",
+      content: "fix it",
+      idle: false,
+      initial: false,
+      log: ".git/gtd-loop.log",
+      state: "build.fixing",
+      actor: "agent",
+      workflow: "feature",
+      changes: [],
+      next: null,
+    })
+  })
+
+  it("carries initial independently of idle, always present", () => {
+    for (const [idle, initial] of [
+      [false, true],
+      [true, true],
+      [false, false],
+    ] as const) {
+      const parsed = JSON.parse(renderJsonLine({ kind: "script", idle, initial })) as Record<
+        string,
+        unknown
+      >
+      expect(parsed.idle).toBe(idle)
+      expect(parsed.initial).toBe(initial)
+    }
+  })
+
+  it("uses the stall diagnosis as content, never the rendered content, at kind stalled", () => {
+    const line = renderJsonLine({ rendered: rendered(), kind: "stalled" })
+    const parsed = JSON.parse(line) as { content: string }
+    expect(parsed.content).toBe(stallDiagnosis("build.fixing", "agent"))
+    expect(parsed.content).not.toBe("fix it")
+  })
+
+  it("gates session/validate to kind prompt, dropping them at every other kind", () => {
+    const session = { id: "8f2c", resume: true }
+    for (const kind of BEAT_KINDS.filter((k) => k !== "prompt")) {
+      const line = renderJsonLine({
+        kind,
+        session,
+        validate: "gtd check qa 'TODO.md'",
+      })
+      const parsed = JSON.parse(line) as Record<string, unknown>
+      expect(parsed.session).toBeUndefined()
+      expect(parsed.validate).toBeUndefined()
+    }
+  })
+
+  it("emits session and validate at kind prompt", () => {
+    const session = { id: "8f2c", resume: true }
+    const line = renderJsonLine({ kind: "prompt", session, validate: "gtd check qa 'TODO.md'" })
+    const parsed = JSON.parse(line) as Record<string, unknown>
+    expect(parsed.session).toEqual({ id: "8f2c", resume: true })
+    expect(parsed.validate).toBe("gtd check qa 'TODO.md'")
+  })
+
+  it("omits session/validate at kind prompt when the caller supplied none, never emitting null", () => {
+    const line = renderJsonLine({ kind: "prompt" })
+    const parsed = JSON.parse(line) as Record<string, unknown>
+    expect("session" in parsed).toBe(false)
+    expect("validate" in parsed).toBe(false)
+  })
+
+  it("emits model/system/memory/file/mode/label at every kind when present, never null", () => {
+    const r = rendered({
+      model: "opus",
+      system: "You are a careful senior engineer.",
+      memory: "build#a1b2c3d",
+      file: "TODO.md",
+      mode: "qa",
+      label: "Fixing",
+    })
+    for (const kind of BEAT_KINDS) {
+      const line = renderJsonLine({ rendered: r, kind })
+      const parsed = JSON.parse(line) as Record<string, unknown>
+      expect(parsed.model).toBe("opus")
+      expect(parsed.system).toBe("You are a careful senior engineer.")
+      expect(parsed.memory).toBe("build#a1b2c3d")
+      expect(parsed.file).toBe("TODO.md")
+      expect(parsed.mode).toBe("qa")
+      expect(parsed.label).toBe("Fixing")
+      expect(parsed).not.toHaveProperty("edges")
+    }
+  })
+
+  it("emits skills as an array of trimmed names at kind prompt", () => {
+    const withSkills = rendered({ skills: ["code-review", "testing"] })
+    const line = renderJsonLine({ rendered: withSkills, kind: "prompt" })
+    const parsed = JSON.parse(line) as Record<string, unknown>
+    expect(parsed.skills).toEqual(["code-review", "testing"])
+  })
+
+  it("omits skills at capture, message, script and stalled — even when the source rest carries them, the leak this design prevents", () => {
+    const withSkills = rendered({ skills: ["code-review", "testing"] })
+    for (const kind of BEAT_KINDS.filter((k) => k !== "prompt")) {
+      const line = renderJsonLine({ rendered: withSkills, kind })
+      const parsed = JSON.parse(line) as Record<string, unknown>
+      expect("skills" in parsed).toBe(false)
+    }
+  })
+
+  it("omits skills entirely (never []) when the list is empty or absent, at kind prompt", () => {
+    const empty = renderJsonLine({ rendered: rendered({ skills: [] }), kind: "prompt" })
+    expect("skills" in (JSON.parse(empty) as Record<string, unknown>)).toBe(false)
+
+    const absent = renderJsonLine({ rendered: rendered(), kind: "prompt" })
+    expect("skills" in (JSON.parse(absent) as Record<string, unknown>)).toBe(false)
+  })
+
+  it("omits system when its rendered value is the empty string, unlike model which carries an empty string through", () => {
+    const line = renderJsonLine({ rendered: rendered({ model: "", system: "" }), kind: "prompt" })
+    const parsed = JSON.parse(line) as Record<string, unknown>
+    expect("system" in parsed).toBe(false)
+    expect(parsed.model).toBe("")
+  })
+
+  it("omits optional fields entirely (not undefined/null) when unset", () => {
+    const line = renderJsonLine({ kind: "script" })
+    const parsed = JSON.parse(line) as Record<string, unknown>
+    for (const key of [
+      "session",
+      "model",
+      "system",
+      "validate",
+      "label",
+      "memory",
+      "file",
+      "mode",
+      "edges",
+      "cost",
+      "costByModel",
+      "judge",
+      "skills",
+      "access",
+    ]) {
+      expect(key in parsed).toBe(false)
+    }
+  })
+
+  it("emits keys in the documented order", () => {
+    const r = rendered({
+      model: "opus",
+      system: "You are a careful senior engineer.",
+      memory: "build#a1b2c3d",
+      file: "TODO.md",
+      mode: "qa",
+      label: "Fixing",
+      judge: '{"state":"build.fixing","questions":[]}',
+      skills: ["code-review"],
+    })
+    const line = renderJsonLine({
+      rendered: r,
+      kind: "prompt",
+      idle: false,
+      initial: false,
+      log: ".git/gtd-loop.log",
+      session: { id: "8f2c", resume: true },
+      validate: "gtd check qa 'TODO.md'",
+      changes: [{ status: "M", path: "TODO.md" }],
+      next: { target: "idle" },
+      cost: 12,
+      costByModel: [{ model: "opus", cost: 12 }],
+    })
+    const keys = Object.keys(JSON.parse(line) as Record<string, unknown>)
+    expect(keys).toEqual([
+      "schema",
+      "kind",
+      "content",
+      "idle",
+      "initial",
+      "session",
+      "model",
+      "system",
+      "validate",
+      "log",
+      "state",
+      "actor",
+      "workflow",
+      "label",
+      "memory",
+      "file",
+      "mode",
+      "changes",
+      "next",
+      "cost",
+      "costByModel",
+      "judge",
+      "skills",
+      "access",
+    ])
+  })
+
+  it("emits access at kind prompt, null per side when unrestricted", () => {
+    const bare = JSON.parse(renderJsonLine({ kind: "prompt" })) as Record<string, unknown>
+    expect(bare.access).toEqual({ read: null, write: null })
+    const restricted = JSON.parse(
+      renderJsonLine({
+        rendered: rendered({ access: { read: null, write: [".gtd/REVIEW.md"] } }),
+        kind: "prompt",
+      }),
+    ) as Record<string, unknown>
+    expect(restricted.access).toEqual({ read: null, write: [".gtd/REVIEW.md"] })
+  })
+
+  it("omits access at every kind but prompt, even when the rest carries it", () => {
+    const withAccess = rendered({ access: { read: ["a"], write: ["b"] } })
+    for (const kind of BEAT_KINDS.filter((k) => k !== "prompt")) {
+      const parsed = JSON.parse(renderJsonLine({ rendered: withAccess, kind })) as Record<
+        string,
+        unknown
+      >
+      expect("access" in parsed).toBe(false)
+    }
+  })
+
+  it("ends with a trailing newline", () => {
+    expect(renderJsonLine({ kind: "script" }).endsWith("\n")).toBe(true)
+  })
+
+  it("carries changes verbatim, always present even when empty", () => {
+    const changes = [
+      { status: "M", path: "TODO.md" },
+      { status: "A", path: "REVIEW.md" },
+    ]
+    const line = renderJsonLine({ kind: "prompt", changes })
+    const parsed = JSON.parse(line) as { changes: unknown }
+    expect(parsed.changes).toEqual(changes)
+  })
+
+  it("carries next as null on no match, an object (action omitted when absent) on a match", () => {
+    const noMatch = renderJsonLine({ kind: "prompt" })
+    expect((JSON.parse(noMatch) as { next: unknown }).next).toBeNull()
+
+    const matched = renderJsonLine({
+      kind: "prompt",
+      next: { target: "idle" },
+    })
+    const parsedMatch = JSON.parse(matched) as { next: Record<string, unknown> }
+    expect(parsedMatch.next).toEqual({ target: "idle" })
+    expect("action" in parsedMatch.next).toBe(false)
+
+    const matchedWithAction = renderJsonLine({
+      kind: "prompt",
+      next: { target: "idle" },
+    })
+    const parsedAction = JSON.parse(matchedWithAction) as { next: Record<string, unknown> }
+    expect(parsedAction.next).toEqual({ target: "idle" })
+  })
+
+  it("omits cost/costByModel when cost is zero, emits both when a cost was recorded", () => {
+    const noCost = renderJsonLine({ kind: "prompt" })
+    const parsedNoCost = JSON.parse(noCost) as Record<string, unknown>
+    expect("cost" in parsedNoCost).toBe(false)
+    expect("costByModel" in parsedNoCost).toBe(false)
+
+    const withCost = renderJsonLine({
+      kind: "prompt",
+      cost: 42,
+      costByModel: [{ model: "opus", cost: 42 }],
+    })
+    const parsedWithCost = JSON.parse(withCost) as Record<string, unknown>
+    expect(parsedWithCost.cost).toBe(42)
+    expect(parsedWithCost.costByModel).toEqual([{ model: "opus", cost: 42 }])
+  })
+
+  it("omits judge entirely (not undefined/null) when unset, emits it verbatim when set", () => {
+    const unset = renderJsonLine({ kind: "prompt" })
+    expect("judge" in (JSON.parse(unset) as Record<string, unknown>)).toBe(false)
+
+    const set = renderJsonLine({
+      rendered: rendered({ judge: '{"state":"build.fixing","questions":[]}' }),
+      kind: "prompt",
+    })
+    const parsedSet = JSON.parse(set) as Record<string, unknown>
+    expect(parsedSet.judge).toBe('{"state":"build.fixing","questions":[]}')
+  })
+
+  it("carries no version key", () => {
+    const line = renderJsonLine({ kind: "prompt" })
+    expect("version" in (JSON.parse(line) as Record<string, unknown>)).toBe(false)
+  })
+})
+
+describe("golden bytes", () => {
+  it("renderBeatJson renders a rest with absent optionals as these bytes, schema first", () => {
+    const line = renderJsonLine({ rendered: rendered(), kind: "script", log: ".git/gtd-loop.log" })
+    expect(line).toBe(
+      JSON.stringify({
+        schema: WIRE_SCHEMA,
+        kind: "script",
+        content: "fix it",
+        idle: false,
+        initial: false,
+        log: ".git/gtd-loop.log",
+        state: "build.fixing",
+        actor: "agent",
+        workflow: "feature",
+        changes: [],
+        next: null,
+      }) + "\n",
+    )
+  })
+})
+
+/**
+ * ONE test, looping the ONE kind list (`BEAT_KINDS`, exported from
+ * `Demand.ts`), covering all three places a `BeatKind` must be handled:
+ * `beatDocument` (the JSON side, via `dispatchFieldsOf`'s exhaustive switch),
+ * `DEMAND_BRIEFING` (the plain-render briefing table), and `renderBeatPlain`
+ * itself (whether the status header is actually suppressed). Replaces the
+ * three previously hand-maintained kind lists (this file's own literal, plus
+ * one each in `Demand.test.ts` and `BeatPlain.test.ts`) with the single
+ * source `Demand.ts` now exports — a sixth `BeatKind` member is caught here
+ * (a missing `DEMAND_BRIEFING`/`dispatchFieldsOf` entry fails `tsc` first,
+ * before this test can even run) as well as by this loop actually exercising
+ * every member.
+ */
+describe("exhaustiveness over Demand/BeatKind", () => {
+  it("BeatKind is exactly the five documented members", () => {
+    expect([...BEAT_KINDS].sort()).toEqual(["capture", "message", "prompt", "script", "stalled"])
+  })
+
+  it("every kind: produces a document, has a DEMAND_BRIEFING entry, and the plain header is shown iff the briefing doesn't suppress it", () => {
+    for (const kind of BEAT_KINDS) {
+      const document = documentFor({ kind })
+      expect(() => renderBeatJson(document)).not.toThrow()
+      expect(document.kind).toBe(kind)
+
+      const briefing = DEMAND_BRIEFING[kind]
+      expect(briefing).toBeDefined()
+
+      const plain = renderBeatPlain(document)
+      expect(plain.includes("State: ")).toBe(!briefing.suppressHeader)
+      if (briefing.instructionLine !== undefined) {
+        expect(plain.startsWith(`${briefing.instructionLine}\n`)).toBe(true)
+      }
+    }
+  })
+})

package/src/wire/BeatDocument.ts

@@ -0,0 +1,114 @@
+import type { BeatKind, Demand, DemandSession } from "./Demand.js"
+import type { BeatStatus, NextMatch, StatusChange } from "./BeatStatus.js"
+import type { Actor, ModelCost, StateMode, StateName, StepAccess } from "./types.js"
+import { WIRE_SCHEMA } from "./constants.js"
+
+/** `gtd next --json`'s `next` key — `null` when landing would commit nothing. */
+const nextField = (next: NextMatch | null): { target: string } | null =>
+  next === null ? null : { target: next.target }
+
+/** Unreachable in a well-typed call — used as the `default` arm of an exhaustive switch over `Demand["kind"]`, so a future `BeatKind` member that isn't handled fails `tsc`, not just review. */
+const assertNeverDemand = (demand: never): never => {
+  throw new Error(`unreachable demand: ${JSON.stringify(demand)}`)
+}
+
+/**
+ * The ONE exhaustive switch translating a `Demand` into its wire
+ * `session`/`validate`/`skills`/`access` set — only the `prompt` variant carries
+ * any of them, and every other member is listed explicitly (not a
+ * `default:` fallthrough) so adding a sixth `BeatKind` without adding its
+ * case here fails `tsc` at the `assertNeverDemand` call, not silently
+ * falling through to "no session."
+ */
+const dispatchFieldsOf = (
+  demand: Demand,
+): {
+  readonly session: DemandSession | undefined
+  readonly validate: string | undefined
+  readonly skills: readonly string[] | undefined
+  readonly access: StepAccess | undefined
+} => {
+  switch (demand.kind) {
+    case "prompt":
+      return {
+        session: demand.session,
+        validate: demand.validate,
+        skills: demand.skills,
+        access: demand.access,
+      }
+    case "capture":
+    case "message":
+    case "script":
+    case "stalled":
+      return { session: undefined, validate: undefined, skills: undefined, access: undefined }
+    default:
+      return assertNeverDemand(demand)
+  }
+}
+
+/** One beat's whole field set, flattened — the ONE object `renderBeatJson` renders from, in the object's own key order (also the JSON key order). */
+export interface BeatDocument {
+  readonly schema: number
+  readonly kind: BeatKind
+  readonly content: string
+  readonly idle: boolean
+  readonly initial: boolean
+  readonly session: DemandSession | undefined
+  readonly model: string | undefined
+  readonly system: string | undefined
+  readonly validate: string | undefined
+  readonly log: string
+  readonly state: StateName
+  readonly actor: Actor
+  readonly workflow: string
+  readonly label: string | undefined
+  readonly memory: string | undefined
+  readonly file: string | undefined
+  readonly mode: StateMode | undefined
+  readonly changes: readonly StatusChange[]
+  readonly next: { readonly target: string } | null
+  readonly cost: number | undefined
+  readonly costByModel: readonly ModelCost[] | undefined
+  readonly judge: string | undefined
+  readonly skills: readonly string[] | undefined
+  readonly access: StepAccess | undefined
+}
+
+/**
+ * Flatten a `Demand` plus its `BeatStatus` into the single 24-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`).
+ */
+export const beatDocument = (demand: Demand, status: BeatStatus): BeatDocument => {
+  const { session, validate, skills, access } = dispatchFieldsOf(demand)
+  const hasCost = status.cost > 0
+  return {
+    schema: WIRE_SCHEMA,
+    kind: demand.kind,
+    content: demand.content,
+    idle: status.idle,
+    initial: status.initial,
+    session,
+    model: status.model,
+    system: status.system,
+    validate,
+    log: status.log,
+    state: status.state,
+    actor: status.actor,
+    workflow: status.workflow,
+    label: status.label,
+    memory: status.memory,
+    file: status.file,
+    mode: status.mode,
+    changes: status.changes,
+    next: nextField(status.next),
+    cost: hasCost ? status.cost : undefined,
+    costByModel: hasCost ? status.costByModel : undefined,
+    judge: status.judge,
+    skills,
+    access,
+  }
+}
+
+export const renderBeatJson = (document: BeatDocument): string => JSON.stringify(document) + "\n"

package/src/wire/BeatPlain.test.ts

@@ -0,0 +1,113 @@
+import { describe, expect, it } from "vitest"
+import {
+  beatDocument,
+  demandOf,
+  type BeatKind,
+  statusOf,
+  type RenderedDemandSource,
+} from "./index.js"
+import { renderBeatPlain } from "./BeatPlain.js"
+
+const rendered = (overrides: Partial<RenderedDemandSource> = {}): RenderedDemandSource => ({
+  state: "build.fixing",
+  actor: "agent",
+  content: "fix it",
+  ...overrides,
+})
+
+const documentFor = (kind: BeatKind, content: string, rest: Partial<RenderedDemandSource> = {}) => {
+  const r = rendered({ content, ...rest })
+  const demand = demandOf({ rendered: r, kind })
+  const status = statusOf({
+    rendered: r,
+    idle: false,
+    initial: false,
+    workflow: "feature",
+    log: "log",
+    changes: [{ status: "M", path: "TODO.md" }],
+    next: { target: "idle" },
+    cost: 0,
+    costByModel: [],
+  })
+  return beatDocument(demand, status)
+}
+
+const HEADER =
+  "State: build.fixing\nAwaits: agent\nWorkflow: feature\nPending:\n  M TODO.md\nNext: → idle"
+
+describe("renderBeatPlain", () => {
+  it("prepends the run instruction, then shows header, blank line, content verbatim at kind script", () => {
+    expect(renderBeatPlain(documentFor("script", "npm test"))).toBe(
+      `Run this script:\n${HEADER}\n\nnpm test\n`,
+    )
+  })
+
+  it("shows header, blank line, content verbatim at kind message — no instruction line", () => {
+    expect(renderBeatPlain(documentFor("message", "write NOTE.md"))).toBe(
+      `${HEADER}\n\nwrite NOTE.md\n`,
+    )
+  })
+
+  it("prepends prose stating the edit is already made and gtd land will land it, at kind capture", () => {
+    const plain = renderBeatPlain(documentFor("capture", "already edited"))
+    expect(plain).toBe(
+      `The edit is already made — run \`gtd land\` to land it.\n${HEADER}\n\nalready edited\n`,
+    )
+    expect(plain).toMatch(/already made/)
+    expect(plain).toContain("gtd land")
+  })
+
+  it("shows header, blank line, the stall diagnosis (never the rendered content) at kind stalled", () => {
+    const plain = renderBeatPlain(documentFor("stalled", "would-be prompt"))
+    expect(plain.startsWith(`${HEADER}\n\n`)).toBe(true)
+    expect(plain).toContain('stalled at "build.fixing"')
+    expect(plain).not.toContain("would-be prompt")
+  })
+
+  it("a stalled beat at a prompt state whose machine declares system: prints its stall diagnosis with no System: line and no persona text", () => {
+    const document = documentFor("stalled", "would-be prompt", {
+      system: "You are a careful senior engineer.",
+    })
+    const plain = renderBeatPlain(document)
+    expect(plain).not.toContain("System:")
+    expect(plain).not.toContain("You are a careful senior engineer.")
+  })
+
+  it("drops the header entirely at kind prompt, emitting bare content — no self-validate command given", () => {
+    expect(renderBeatPlain(documentFor("prompt", "fix the bug"))).toBe("fix the bug\n")
+  })
+
+  it("at kind prompt, appends the self-validation instruction when a command is given", () => {
+    const document = documentFor("prompt", "fix the bug", { file: "TODO.md", mode: "qa" })
+    expect(renderBeatPlain(document, "gtd check qa 'TODO.md'")).toBe(
+      "fix the bug\n\nBefore finishing your turn, run `gtd check qa 'TODO.md'` — it checks " +
+        "TODO.md — and fix every violation it reports until it exits cleanly. Do not finish " +
+        "while it still reports violations.\n",
+    )
+  })
+
+  it("is byte-identical to a bare prompt render when no self-validate command is given", () => {
+    const document = documentFor("prompt", "fix the bug")
+    expect(renderBeatPlain(document)).toBe(renderBeatPlain(document, undefined))
+  })
+
+  it("plain output at kind prompt is byte-identical whether or not the machine declares system:", () => {
+    const withoutSystem = documentFor("prompt", "fix the bug")
+    const withSystem = documentFor("prompt", "fix the bug", { system: "a persona" })
+    expect(renderBeatPlain(withSystem)).toBe(renderBeatPlain(withoutSystem))
+  })
+
+  it("never prints a Skills: line, in any kind's header or the bare prompt body", () => {
+    const kinds: readonly BeatKind[] = ["capture", "message", "script", "stalled", "prompt"]
+    for (const kind of kinds) {
+      const plain = renderBeatPlain(documentFor(kind, "fix the bug", { skills: ["code-review"] }))
+      expect(plain).not.toContain("Skills:")
+    }
+  })
+
+  it("plain output at kind prompt is byte-identical whether or not the machine declares skills", () => {
+    const withoutSkills = documentFor("prompt", "fix the bug")
+    const withSkills = documentFor("prompt", "fix the bug", { skills: ["code-review"] })
+    expect(renderBeatPlain(withSkills)).toBe(renderBeatPlain(withoutSkills))
+  })
+})