@defrex/autobuild 0.13.0 → 0.14.0

package/packages/core/src/testing/dispatch-read-budget.ts

@@ -0,0 +1,215 @@
+import { expect } from 'bun:test'
+import { DispatchFrontend } from '../cli/dispatch-frontend'
+import type { DispatchChildResult } from '../cli/dispatch-process'
+import { createTerminalModeController } from '../cli/terminal-restore'
+import { DISPATCHER, humanActor } from '../events/envelope'
+import type { BuildStore } from '../store/types'
+
+const tickCounters = {
+  merged: 0,
+  closed: 0,
+  conflicted: 0,
+  abandoned: 0,
+  discarded: 0,
+  janitorFailed: 0,
+  recovered: 0,
+  dispatchFailed: 0,
+  resumed: 0,
+  swept: 0,
+  dispatched: 0,
+  authored: 0,
+  bounced: 0,
+  claimRaces: 0,
+  invalidTickets: 0,
+  dependencyBlocked: 0,
+  harvestStarted: 0,
+  harvestResumed: 0,
+  harvestCompleted: 0,
+  harvestEscalated: 0,
+  harvestFailed: 0,
+}
+
+/** Run the actual frontend lifecycle with a deterministic child and manual
+ * refreshes. Instrument the backing boundary, including HTTP server reads. */
+export async function dispatchReadBudget(store: BuildStore, backing: BuildStore): Promise<void> {
+  const repo = '/dashboard-read-budget'
+  await backing.ensureRepo(repo)
+  const metrics = {
+    rows: 0,
+    events: 0,
+    state: 0,
+    snapshots: 0,
+    digests: 0,
+    records: 0,
+    high: 0,
+    puts: 0,
+  }
+  const putSnapshot = backing.putReducerSnapshot.bind(backing)
+  backing.putReducerSnapshot = async (...args) => {
+    metrics.puts++
+    return putSnapshot(...args)
+  }
+  const getEvents = backing.getRepoEvents.bind(backing)
+  const getState = backing.getRepoStateEvents.bind(backing)
+  const getSnapshot = backing.getReducerSnapshot.bind(backing)
+  const getDigests = backing.getRepoBuildDigests.bind(backing)
+  const getRepo = backing.getRepo.bind(backing)
+  const getHigh = backing.getRepoHighWater.bind(backing)
+  backing.getRepoEvents = async (repo, since) => {
+    const events = await getEvents(repo, since)
+    metrics.events++
+    metrics.rows += events.length
+    return events
+  }
+  backing.getRepoStateEvents = async (repo) => {
+    metrics.state++
+    return getState(repo)
+  }
+  backing.getReducerSnapshot = async (...args) => {
+    metrics.snapshots++
+    return getSnapshot(...args)
+  }
+  backing.getRepoBuildDigests = async (repo) => {
+    metrics.digests++
+    return getDigests(repo)
+  }
+  backing.getRepo = async (repo) => {
+    metrics.records++
+    return getRepo(repo)
+  }
+  backing.getRepoHighWater = async (repo) => {
+    metrics.high++
+    return getHigh(repo)
+  }
+  let now = 0
+  let finish!: (result: DispatchChildResult) => void
+  let started!: () => void
+  let childRun = ''
+  const startup = new Promise<void>((resolve) => {
+    started = resolve
+  })
+  const frontend = new DispatchFrontend({
+    repo,
+    storeRef: 'test',
+    store,
+    env: {},
+    once: true,
+    clock: () => new Date(now),
+    input: { start: () => () => {} },
+    terminal: {
+      columns: 100,
+      rows: 24,
+      interactive: true,
+      write: () => {},
+      modes: createTerminalModeController(
+        () => {},
+        () => {},
+      ),
+    },
+    launchChild: ({ run }) => {
+      childRun = run
+      const completed = new Promise<DispatchChildResult>((resolve) => {
+        finish = resolve
+      })
+      void backing
+        .appendRepoWithArtifacts(
+          repo,
+          [
+            {
+              kind: 'config',
+              content: JSON.stringify({
+                capacity: 4,
+                roles: { default: { runtime: 'claude' } },
+                tickets: { source: 'file', readyState: 'ready' },
+              }),
+            },
+          ],
+          (artifacts) => ({
+            actor: DISPATCHER,
+            type: 'dispatcher.run-started',
+            payload: {
+              run,
+              pid: 1,
+              roleWarnings: [],
+              effectiveConfig: { kind: artifacts[0]!.kind, rev: artifacts[0]!.revision },
+            },
+          }),
+        )
+        .then(started)
+      return { completed, stop: async () => {} }
+    },
+  })
+  const running = frontend.run()
+  await startup
+  // Exercise exactly the controller operation used by timers and actions,
+  // without a wall-clock timer determining the batch boundaries.
+  const refresh = () => (frontend as unknown as { renderOnce(): Promise<void> }).renderOnce()
+  await refresh()
+  const initialSize = JSON.stringify(
+    (await getSnapshot({ kind: 'repo', repo }, 'dispatchFrontend', 2))?.state,
+  ).length
+  let recordReads: number | undefined
+  try {
+    for (let batch = 0; batch < 24; batch++) {
+      for (let i = 0; i < 128; i++) {
+        await backing.appendRepo(repo, {
+          actor: DISPATCHER,
+          type: 'dispatcher.tick-completed',
+          payload: {
+            run: childRun,
+            queued: 0,
+            counters: tickCounters,
+            janitorDiagnostics: [],
+            ticketDiagnostics: [],
+            creationDiagnostics: [],
+            dependencyDiagnostics: [],
+          },
+        })
+      }
+      const before = { ...metrics }
+      now += 6000
+      await refresh()
+      expect(metrics.puts - before.puts).toBe(1)
+      expect(metrics.rows - before.rows).toBe(128)
+      expect(metrics.events - before.events).toBe(1)
+      expect(metrics.state - before.state).toBe(0)
+      expect(metrics.snapshots - before.snapshots).toBe(0)
+      expect(metrics.digests - before.digests).toBe(1)
+      expect(metrics.high - before.high).toBe(0)
+      recordReads ??= metrics.records - before.records
+      expect(metrics.records - before.records).toBe(recordReads)
+      const size = JSON.stringify(
+        (await getSnapshot({ kind: 'repo', repo }, 'dispatchFrontend', 2))?.state,
+      ).length
+      // First advancement adds the child's identity; ticks add nothing.
+      expect(size).toBeLessThan(initialSize + 1000)
+      const rows = metrics.rows
+      await refresh()
+      expect(metrics.rows).toBe(rows)
+    }
+    // Advance the clock across rejected equal-cursor saves. A standby can
+    // remain quiet indefinitely; each 500 ms frame must not upload its cache.
+    const beforeQuiet = { ...metrics }
+    for (let poll = 0; poll < 40; poll++) {
+      now += 500
+      await refresh()
+    }
+    expect(metrics.puts - beforeQuiet.puts).toBe(4)
+    expect(metrics.rows).toBe(beforeQuiet.rows)
+  } finally {
+    finish({ outcome: 'normal', exitCode: 0 })
+    await running
+  }
+  await backing.appendRepo(repo, {
+    actor: humanActor('test'),
+    type: 'dispatcher.pause-set',
+    payload: { enabled: true },
+  })
+  // A new invocation restores persisted state without any bounded/full seed.
+  const { DispatchRepositoryFeed } = await import('../cli/dispatch-repository-feed')
+  const feed = new DispatchRepositoryFeed(store, repo, () => new Date(now))
+  const before = { ...metrics }
+  expect((await feed.refresh()).length).toBe(1)
+  expect(metrics.rows - before.rows).toBe(1)
+  expect(metrics.state - before.state).toBe(0)
+}

package/packages/core/src/testing/index.ts

@@ -64,3 +64,11 @@ export { resolveHarvestCliEnv } from '../cli/env'
 export { buildHarvestContext, submitHarvestProposals, submitHarvestVerdict } from '../cli/harvest'
 export { abConnect, abDisconnect } from '../cli/connect'
 export { ProjectCredentials } from '../cli/project-credentials'
+
+export { dispatchReadBudget } from './dispatch-read-budget'
+
+export {
+  reducedReadBudget,
+  countHistoricalRows,
+  type ReducedReadCosts,
+} from './reduced-read-budget'

package/packages/core/src/testing/reduced-read-budget.ts

@@ -0,0 +1,462 @@
+import { mkdtemp, writeFile, rm } from 'node:fs/promises'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import { abDispatch } from '../cli/dispatch'
+import { randomUuids } from '../ids'
+import { ScriptedAgentRunner, defaultTurnResult } from '../ports/runner/fake'
+import { Dispatcher } from '../processes/dispatcher'
+import { FakeTicketSource } from '../ports/tickets/fake'
+import { FakeWorkspaceProvider } from '../ports/workspace/fake'
+import { FakeForge } from '../ports/forge/fake'
+import { sequentialIds } from '../ids'
+import { parseConfig } from '../config/load'
+import {
+  getOperatorDashboard,
+  listOperatorBuilds,
+  getOperatorBuild,
+  getRepositoryStatus,
+} from '../operator/query'
+import { buildRegistry } from '../operator/registry'
+import { expect } from 'bun:test'
+import type { BuildStore } from '../store/types'
+import { KERNEL, DISPATCHER, humanActor } from '../events/envelope'
+import {
+  readBuildFacts,
+  readBuildStreamSeed,
+  readRepositoryFacts,
+  readRepositoryAttention,
+  readBuildDigests,
+  readDispatcherRunFacts,
+  readOpenTick,
+} from '../store/reduced-reads'
+import { RepoViewStore } from '../processes/repo-view'
+import { abWatch, decodeCursor } from '../cli/watch'
+import { abWait } from '../cli/wait'
+import type { Exec } from '../ports/workspace/git-worktree'
+
+export interface ReducedReadCosts {
+  events: number
+  metadata: number
+  bytes: number
+  historicalEvents: number
+  history?: { repo: string; through: number }
+}
+const repo = '/reduced-read-budget'
+const slug = 'reduced-budget'
+const exec: Exec = async (args) =>
+  args[1] === 'remote'
+    ? { stdout: '', stderr: 'no origin', exitCode: 2 }
+    : { stdout: `${repo}/.git\n${repo}/.git\n${repo}\n`, stderr: '', exitCode: 0 }
+
+/** Shared actual-consumer scenario. Costs must instrument SQL statement results,
+ * including private reducer storage, rather than just public getEvents calls. */
+export async function reducedReadBudget(opts: {
+  store: BuildStore
+  costs: ReducedReadCosts
+  fresh: () => Promise<BuildStore>
+  storeRef?: string
+}) {
+  const { store, costs } = opts
+  await store.ensureRepo(repo)
+  const config = parseConfig(
+    '[tickets]\nsource="file"\nreadyState="ready"\n[verify]\nsteps=[]\n[finalize]\nsteps=[]',
+  )
+  const { verify: _verify, finalize: _finalize, ...root } = config
+  const configArtifact = await store.putRepoArtifact(repo, {
+    kind: 'dispatcher-effective-config',
+    content: JSON.stringify({ ...root, verify: { steps: [] }, finalize: { steps: [] } }),
+  })
+  await store.appendRepo(repo, {
+    actor: DISPATCHER,
+    type: 'dispatcher.run-started',
+    payload: {
+      run: 'budget-run',
+      pid: 1,
+      roleWarnings: [],
+      effectiveConfig: { kind: configArtifact.kind, rev: configArtifact.revision },
+    },
+  })
+  await store.createBuild({ slug, repo })
+  await store.append(slug, {
+    actor: KERNEL,
+    type: 'runner.attached',
+    payload: { instance: 'budget', host: 'host' },
+  })
+  await store.append(slug, {
+    actor: KERNEL,
+    type: 'finalize.completed',
+    payload: { pr: { number: 7, url: 'https://example.test/7', headSha: 'abc' } },
+  })
+  await store.append(slug, {
+    actor: humanActor('human'),
+    type: 'build.auto-merge-requested',
+    payload: {},
+  })
+  const reset = () => {
+    costs.events = 0
+    costs.metadata = 0
+    costs.bytes = 0
+  }
+  let repositoryBytes: number | undefined
+  for (const length of [32, 256]) {
+    for (let i = 0; i < length; i++) {
+      await store.append(slug, {
+        actor: humanActor('human'),
+        type: 'build.auto-merge-requested',
+        payload: {},
+      })
+      await store.appendRepo(repo, {
+        actor: humanActor('human'),
+        type: 'dispatcher.intake-set',
+        payload: { enabled: true },
+      })
+      const run = `old-${length}-${String(i).padStart(4, '0')}`
+      await store.appendRepo(repo, {
+        actor: DISPATCHER,
+        type: 'dispatcher.run-started',
+        payload: {
+          run,
+          pid: 1,
+          roleWarnings: [],
+          effectiveConfig: { kind: configArtifact.kind, rev: configArtifact.revision },
+        },
+      })
+      await store.appendRepo(repo, {
+        actor: DISPATCHER,
+        type: 'dispatcher.run-stopped',
+        payload: { run, outcome: 'normal' },
+      })
+    }
+    await store.appendRepo(repo, {
+      actor: DISPATCHER,
+      type: 'dispatcher.run-started',
+      payload: {
+        run: 'budget-run',
+        pid: 1,
+        roleWarnings: [],
+        effectiveConfig: { kind: configArtifact.kind, rev: configArtifact.revision },
+      },
+    })
+    const factsBytes = Buffer.byteLength(
+      JSON.stringify((await readRepositoryFacts(store, repo)).value),
+    )
+    if (repositoryBytes !== undefined) expect(factsBytes).toBeLessThan(repositoryBytes + 512)
+    repositoryBytes = factsBytes
+    // Warm persisted values independently of any consumer instance.
+    await readBuildStreamSeed(store, slug)
+    await readBuildFacts(store, slug)
+    await readRepositoryFacts(store, repo)
+    await readBuildDigests(store, repo)
+    await readRepositoryAttention(store, repo)
+    const handle = await opts.fresh()
+    const cold = new Proxy(handle, {
+      get(target, key) {
+        if (key === 'close') return async () => {}
+        const value = Reflect.get(target, key, target)
+        return typeof value === 'function' ? value.bind(target) : value
+      },
+    })
+    await coldDispatchOnceBudget(store, cold, length, costs)
+    reset()
+    const view = new RepoViewStore(cold, { repo })
+    await view.refresh()
+    expect((await view.buildFacts(slug)).state.pr?.number).toBe(7)
+    expect((await view.buildState(slug)).status).toBe('running')
+    expect(costs.events).toBe(0)
+    expect(costs.metadata).toBeLessThan(100)
+
+    const dispatcher = () =>
+      new Dispatcher({
+        store: cold,
+        repo,
+        config,
+        tickets: new FakeTicketSource([]),
+        workspaces: new FakeWorkspaceProvider({ root: '/budget-workspaces', mode: 'logical' }),
+        forge: new FakeForge(),
+        ids: sequentialIds(),
+        clock: () => new Date(1000),
+        exec,
+        launchRunner: async () => 'scheduled',
+      })
+    await dispatcher().tick({ acceptNewWork: false })
+    await getOperatorDashboard({ store: cold, repo, clock: () => new Date(1000) })
+    reset()
+    await dispatcher().tick({ acceptNewWork: false })
+    await getOperatorDashboard({ store: cold, repo, clock: () => new Date(1000) })
+    await listOperatorBuilds({ store: cold, repo, scope: 'all', now: new Date(1000) })
+    await getOperatorBuild({ store: cold, repo, slug, now: new Date(1000) })
+    await getRepositoryStatus(cold, repo, new Date(1000))
+    await buildRegistry({ store: cold, clock: () => new Date(1000) }).call('builds.get', {
+      repo,
+      slug,
+    })
+    expect(costs.events).toBe(0)
+    expect(costs.metadata).toBeLessThan(400)
+    expect(costs.bytes).toBeLessThan(1_000_000)
+
+    // A fresh watch must suppress historical PR eligibility despite armed
+    // consent at registration, including its first event-bearing poll.
+    reset()
+    let ticks = 0
+    let time = 0
+    const out: string[] = []
+    await abWatch({
+      targetRepo: repo,
+      env: {},
+      exec,
+      storeRef: opts.storeRef ?? '/budget',
+      openStore: () => cold,
+      slugs: [slug],
+      json: true,
+      timeout: '2',
+      now: () => new Date(time),
+      stdout: (line) => out.push(line),
+      stderr: () => {},
+      delay: async () => {
+        time += 1000
+        if (++ticks === 1)
+          await store.append(slug, {
+            actor: humanActor('human'),
+            type: 'build.auto-merge-cancelled',
+            payload: {},
+          })
+      },
+    })
+    expect(out).toHaveLength(1)
+    const cursor = JSON.parse(out[0]!).cursor
+    expect(
+      decodeCursor(cursor, { store: opts.storeRef ?? '/budget', repo }).deliveredAttention,
+    ).toEqual([JSON.stringify([slug, 7])])
+    expect(costs.events).toBeLessThanOrEqual(4)
+    expect(costs.metadata).toBeLessThan(100)
+
+    await store.append(slug, {
+      actor: humanActor('human'),
+      type: 'build.auto-merge-requested',
+      payload: {},
+    })
+    await readBuildStreamSeed(store, slug)
+    reset()
+    let discoveryTick = 0
+    time = 0
+    const discovered = new Proxy(cold, {
+      get(target, key) {
+        if (key === 'listBuilds')
+          return async () => (discoveryTick === 0 ? [] : target.listBuilds())
+        const value = Reflect.get(target, key, target)
+        return typeof value === 'function' ? value.bind(target) : value
+      },
+    })
+    const discoveryOut: string[] = []
+    await abWatch({
+      targetRepo: repo,
+      env: {},
+      exec,
+      storeRef: opts.storeRef ?? '/budget',
+      openStore: () => discovered,
+      json: true,
+      timeout: '3',
+      now: () => new Date(time),
+      stdout: (line) => discoveryOut.push(line),
+      stderr: () => {},
+      delay: async () => {
+        time += 1000
+        if (++discoveryTick === 2)
+          await store.append(slug, {
+            actor: humanActor('human'),
+            type: 'build.auto-merge-cancelled',
+            payload: {},
+          })
+      },
+    })
+    expect(discoveryOut).toHaveLength(1)
+    expect(costs.events).toBeLessThanOrEqual(6)
+    expect(costs.metadata).toBeLessThan(180)
+
+    // Wait applies its current-attention policy instead of watch suppression.
+    await readBuildStreamSeed(store, slug)
+    reset()
+    const waitOut: string[] = []
+    const result = await abWait({
+      targetRepo: repo,
+      env: {},
+      exec,
+      storeRef: opts.storeRef ?? '/budget',
+      openStore: () => cold,
+      slugs: [slug],
+      forValues: ['attention'],
+      json: true,
+      now: () => new Date(time),
+      stdout: (line) => waitOut.push(line),
+      stderr: () => {},
+    })
+    expect(result).toBe(0)
+    expect(JSON.parse(waitOut[0]!).observation.pr.number).toBe(7)
+    expect(costs.events).toBe(0)
+    expect(costs.metadata).toBeLessThan(40)
+    await store.append(slug, {
+      actor: humanActor('human'),
+      type: 'build.auto-merge-requested',
+      payload: {},
+    })
+    await readBuildStreamSeed(store, slug)
+    reset()
+    let waitTick = 0
+    time = 0
+    const polled: string[] = []
+    const waited = await abWait({
+      targetRepo: repo,
+      env: {},
+      exec,
+      storeRef: opts.storeRef ?? '/budget',
+      openStore: () => cold,
+      slugs: [slug],
+      forValues: ['attention'],
+      json: true,
+      timeout: '4',
+      now: () => new Date(time),
+      stdout: (line) => polled.push(line),
+      stderr: () => {},
+      delay: async () => {
+        time += 1000
+        // The first pass stays idle; the next delivers the first event batch.
+        if (++waitTick === 1) {
+          expect(costs.events).toBe(0)
+          expect(costs.metadata).toBeLessThan(40)
+        }
+        if (waitTick === 2) {
+          expect(costs.events).toBe(0)
+          await store.append(slug, {
+            actor: humanActor('human'),
+            type: 'build.auto-merge-cancelled',
+            payload: {},
+          })
+        }
+      },
+    })
+    expect(waited).toBe(0)
+    expect(waitTick).toBe(2)
+    expect(JSON.parse(polled[0]!).observation.pr.number).toBe(7)
+    expect(costs.events).toBeLessThanOrEqual(2)
+    expect(costs.metadata).toBeLessThan(50)
+  }
+}
+
+/** Exercise the real outer DispatchLoop with a new invocation identity. Only
+ * shared values are warmed: no parameterized run value may hide a cold replay. */
+async function coldDispatchOnceBudget(
+  store: BuildStore,
+  cold: BuildStore,
+  length: number,
+  costs: ReducedReadCosts,
+) {
+  const onceRepo = 'https://github.com/budget/cold-once'
+  await store.ensureRepo(onceRepo)
+  for (let i = 0; i < length; i++)
+    await store.appendRepo(onceRepo, {
+      actor: humanActor('human'),
+      type: 'dispatcher.intake-set',
+      payload: { enabled: false },
+    })
+  const boundary = (await readRepositoryFacts(store, onceRepo)).cursor
+  const directory = await mkdtemp(join(tmpdir(), 'ab-cold-once-'))
+  try {
+    await writeFile(
+      join(directory, 'autobuild.toml'),
+      `[roles.default]
+runtime = "claude"
+[tickets]
+source = "file"
+readyState = "ready"
+[verify]
+steps = []
+[finalize]
+steps = []
+`,
+    )
+    const checked = new Proxy(cold, {
+      get(target, key) {
+        if (key === 'getReducerValue')
+          return (...args: Parameters<BuildStore['getReducerValue']>) => {
+            expect(['dispatcherRunFacts', 'openTick']).not.toContain(args[1].reducer)
+            return target.getReducerValue(...args)
+          }
+        const value = Reflect.get(target, key, target)
+        return typeof value === 'function' ? value.bind(target) : value
+      },
+    })
+    costs.events = 0
+    costs.metadata = 0
+    costs.bytes = 0
+    costs.historicalEvents = 0
+    costs.history = { repo: onceRepo, through: boundary }
+    const run = `never-read-once-${length}`
+    await abDispatch({
+      targetRepo: directory,
+      repo: onceRepo,
+      env: {},
+      exec: async (args) =>
+        args[1] === 'remote'
+          ? { stdout: `${onceRepo}.git\n`, stderr: '', exitCode: 0 }
+          : {
+              stdout: `${directory}/.git\n${directory}/.git\n${directory}\n`,
+              stderr: '',
+              exitCode: 0,
+            },
+      stdout: () => {},
+      stderr: () => {},
+      once: true,
+      plain: true,
+      kernelRunId: run,
+      storeRef: '/budget',
+      wire: () => ({
+        store: checked,
+        storeRef: '/budget',
+        tickets: new FakeTicketSource([]),
+        forge: new FakeForge(),
+        workspaces: new FakeWorkspaceProvider({ root: '/once-workspaces', mode: 'logical' }),
+        buildExecution: {
+          start: () => {
+            throw new Error('no builds in once budget')
+          },
+        },
+        runtimes: {
+          claude: {
+            runner: new ScriptedAgentRunner({ script: () => defaultTurnResult() }),
+            servesModels: [],
+          },
+        },
+        ids: sequentialIds(),
+        uuids: randomUuids(),
+        clock: () => new Date(1000),
+      }),
+    })
+    const finished = (await readRepositoryFacts(checked, onceRepo)).value.recentRuns.find(
+      ([id]) => id === run,
+    )?.[1]
+    expect(finished?.completed?.type).toBe('dispatcher.tick-completed')
+    expect(finished?.stop?.type).toBe('dispatcher.run-stopped')
+    // The same fresh invocation may fail before writing its start fact.
+    expect(
+      (await readDispatcherRunFacts(checked, onceRepo, `never-started-${length}`, false)).value,
+    ).toEqual({})
+    expect(await readOpenTick(checked, onceRepo, `never-started-${length}`, false)).toBe(false)
+    expect(costs.historicalEvents).toBe(0)
+    expect(costs.events).toBeLessThanOrEqual(32)
+    expect(costs.metadata).toBeLessThan(300)
+    expect(costs.bytes).toBeLessThan(1_000_000)
+  } finally {
+    delete costs.history
+    await rm(directory, { recursive: true, force: true })
+  }
+}
+
+/** SQL result instrumentation handles both raw object rows and Drizzle values. */
+export function countHistoricalRows(costs: ReducedReadCosts, rows: unknown): number {
+  if (!costs.history || !Array.isArray(rows)) return 0
+  return rows.filter((row) => {
+    const repo = Array.isArray(row) ? row[0] : row?.repo
+    const seq = Number(Array.isArray(row) ? row[1] : row?.seq)
+    return repo === costs.history!.repo && seq <= costs.history!.through
+  }).length
+}

package/skills/guide/SKILL.md

@@ -1823,7 +1823,12 @@ cursor from a different repository or store is rejected.
 Dispatcher liveness is also visible through `ab repository status --json`:
 `dispatcher.holder` identifies the unexpired repository lease owner, independently
 of `latestRun`. Heartbeat age measures attributable renewals; tick age measures
-durable progress. Missing historical evidence is null. The liveness query uses
+actual tick completion. Successful unchanged ticks leave no journal pair; bounded,
+lease-fenced repository telemetry still records each actual completion and its
+outcome. Last-tick age refreshes independently of the event cursor and never uses
+heartbeat as completion evidence. Open telemetry protects unsafe work during
+shutdown; historical journals retain their boundary fallback. Missing historical
+evidence is null. The liveness query uses
 bounded repository facts first, with a full-history fallback when a later
 invocation hides the holder start or the latest stop. Other state reads retain
 their bounded semantics.