main
1import assert from 'node:assert/strict'
2import { existsSync } from 'node:fs'
3import { mkdtemp, readFile, writeFile } from 'node:fs/promises'
4import { tmpdir } from 'node:os'
5import { gunzipSync } from 'node:zlib'
6import { join, resolve } from 'node:path'
7import { test } from 'node:test'
8import { chartPng } from '../scripts/cd/charts.ts'
9import { cfWorkdir } from '../scripts/cd/cf.ts'
10import { canarySplit, writeDebrief } from '../scripts/cd/debrief.ts'
11import { fullSplit, isTrafficSplit, trafficSplit } from '../scripts/cd/deploy-plan.ts'
12import { appendFalsePositive, parseEvent, readEvents, RunLog, validateRun, type CdEvent } from '../scripts/cd/log.ts'
13import { createdTokenSecret, harvestSecrets } from '../scripts/cd/redact.ts'
14import { checkNode } from '../scripts/cd/preflight.ts'
15import { doraText } from '../scripts/cd/report.ts'
16import { Secret } from '../scripts/cd/secret.ts'
17import { FAST_BURN } from '../scripts/cd/slo.ts'
19const VERSION = '8c1af0e2-7b3d-4c1a-9e20-6f0a1b2c3d4e'
20const PREVIOUS = '1aa0bb11-2222-4333-8444-555566667777'
22async function temp(): Promise<string> {
23 return mkdtemp(join(tmpdir(), 'ply-cd-'))
24}
26/** The stored capture of command event `seq`'s stdout or stderr, ungzipped. */
27async function capture(log: RunLog, seq: number, stream: 'stdout' | 'stderr'): Promise<string> {
28 const event = log.recorded().find(item => item.seq === seq)
29 if (!event || event.kind !== 'command') throw new Error(`no command ${seq}`)
30 const path = stream === 'stdout' ? event.payload.stdoutPath : event.payload.stderrPath
31 return gunzipSync(await readFile(join(log.dir, path))).toString('utf8')
32}
34test('cf runs from the repo directory', () => {
35 const cwd = cfWorkdir().replace(/\/$/, '')
36 assert.equal(resolve(cwd), cwd)
37 assert.notEqual(cwd, '/')
38 assert.equal(existsSync(join(cwd, 'package.json')), true)
39 assert.equal(existsSync(join(cwd, 'scripts', 'cd', 'cf.ts')), true)
40})
42test('node preflight follows package.json engines', () => {
43 assert.equal(checkNode('v22.23.0'), null)
44 assert.equal(checkNode('v22.23.4'), null)
45 assert.equal(checkNode('v24.22.1'), null)
46 assert.equal(checkNode('v26.12.0'), null)
47 assert.match(checkNode('v22.14.0') ?? '', /does not satisfy package.json engines/)
48 assert.match(checkNode('v22.14.0') ?? '', /node-v24\.22\.1/)
49 assert.match(checkNode('v24.0.0') ?? '', /engines/)
50})
52test('an empty or unbalanced split cannot be built', () => {
53 const zero = trafficSplit(0, VERSION, PREVIOUS)
54 assert.equal(isTrafficSplit(zero), true)
55 if (isTrafficSplit(zero)) assert.deepEqual(zero.versions.map(share => share.percentage), [0, 100])
56 const full = trafficSplit(100, VERSION, PREVIOUS)
57 assert.equal(isTrafficSplit(full), true)
58 if (isTrafficSplit(full)) assert.equal(full.versions.length, 1)
59 assert.equal(isTrafficSplit(trafficSplit(1.5, VERSION, PREVIOUS)), false)
60 assert.equal(isTrafficSplit(trafficSplit(50, VERSION, VERSION)), false)
61 assert.equal(isTrafficSplit(trafficSplit(50, 'nope', PREVIOUS)), false)
62 assert.equal(isTrafficSplit(fullSplit('nope')), false)
63 const alone = fullSplit(PREVIOUS)
64 assert.equal(isTrafficSplit(alone), true)
65})
67test('events round-trip and a decision must cite an observation', async () => {
68 const dir = await temp()
69 const ledger = join(dir, 'ledger.jsonl')
70 const runDir = join(dir, 'run')
71 const log = await RunLog.open(runDir, ledger, 'run-1')
72 await log.started({
73 config: { worker: 'ply' },
74 tools: { node: 'v22.23.4', cf: 'cf 1', git: 'git 2' },
75 plySha: null,
76 plyWebSha: 'abc',
77 host: 'box',
78 })
79 const ref = await log.observation({
80 measurement: { source: 'ramp-step', percent: 1, observedPercent: 0, nextWallP99: 10, previousWallP99: 9 },
81 query: { view: 'events' },
82 from: Date.parse('2026-10-31T21:00:00Z'),
83 to: Date.parse('2026-10-31T21:00:40Z'),
84 raw: '{"events":[]}',
85 })
86 await log.decision({
87 inputs: [ref],
88 rules: [{ name: 'fast_burn', value: FAST_BURN }],
89 outcome: 'advance',
90 reason: 'within burn 14.4 and latency is not slower',
91 })
92 await log.addStep({ percent: 1, burns: { availability: 0, read_latency: null, write_latency: null, correctness: null } })
93 await log.finish(0, null)
94 await log.seal()
95 const events = await readEvents(runDir)
96 assert.deepEqual(events, log.recorded())
97 for (const event of events) {
98 assert.deepEqual(parseEvent(JSON.parse(JSON.stringify(event)) as unknown), event)
99 }
100 const ledgerText = await readFile(ledger, 'utf8')
101 assert.equal(ledgerText, await readFile(join(runDir, 'events.jsonl'), 'utf8'))
102 const manifest = JSON.parse(await readFile(join(runDir, 'manifest.json'), 'utf8')) as { files: Record<string, string> }
103 assert.match(manifest.files['events.jsonl'] ?? '', /^[0-9a-f]{64}$/)
104 assert.equal(manifest.files['manifest.json'], undefined)
105 await assert.rejects(log.observation({ measurement: {}, query: {}, from: 0, to: 1, raw: '{}' }))
106 assert.throws(() => parseEvent({
107 seq: 1, ts: events[0]?.ts, run_id: 'run-1', stage: 'ramp', kind: 'decision',
108 payload: { inputs: [], rules: [{ name: 'fast_burn', value: FAST_BURN }], outcome: 'advance', reason: 'x' },
109 }))
110 const forged = { seq: 1 } as unknown as Parameters<RunLog['decision']>[0]['inputs'][0]
111 const open = await RunLog.open(join(dir, 'run-2'), join(dir, 'ledger-2.jsonl'), 'run-2')
112 await assert.rejects(open.decision({
113 inputs: [forged, forged],
114 rules: [{ name: 'fast_burn', value: FAST_BURN }],
115 outcome: 'hold',
116 reason: 'no observation',
117 }))
118})
120test('plaintext is a Secret and does not require a token prefix', () => {
121 const token = 'art_v2_plaintext_token_value'
122 const found = harvestSecrets({ id: 'tok', plaintext: token, nested: { plaintext: 'art_v2_also_a_secret_value' } })
123 assert.deepEqual(found.map(secret => secret.reveal()), [token, 'art_v2_also_a_secret_value'])
124 const created = 'art_v1_not_a_plaintext_field'
125 const harvested = harvestSecrets({ token: created, id: 'tok' })
126 assert.deepEqual(harvested.map(secret => secret.reveal()), [created])
127 assert.equal(createdTokenSecret({ result: { token: created } }, harvested)?.reveal(), created)
128 assert.equal(harvestSecrets({ token: 'short' }).length, 0)
129 assert.equal(harvestSecrets({ plaintext: '' }).length, 0)
130})
132test('a v2 token never reaches captures', async () => {
133 const v2 = 'art_v2_NEVER_LOG_THIS_TOKEN'
134 const exact = new Secret('exact-match-secret-value')
135 const dir = await temp()
136 const runDir = join(dir, 'run')
137 const log = await RunLog.open(runDir, join(dir, 'ledger.jsonl'), 'run-v2')
138 await log.noteCommand({
139 argv: ['cf', 'tokens', 'create'],
140 cwd: '/workspace',
141 exitCode: 0,
142 durationMs: 1,
143 stdout: `plaintext ${v2}`,
144 stderr: '',
145 })
146 await log.noteCommand({
147 argv: ['cf', exact],
148 cwd: '/workspace',
149 exitCode: 0,
150 durationMs: 1,
151 stdout: exact.reveal(),
152 stderr: exact.reveal(),
153 })
154 await log.finish(0, null)
155 const cap1 = await capture(log, 1, 'stdout')
156 const cap2 = await capture(log, 2, 'stdout')
157 const cap2err = await capture(log, 2, 'stderr')
158 const events = await readFile(join(runDir, 'events.jsonl'), 'utf8')
159 assert.equal(cap1.includes(v2), false)
160 assert.equal(cap1.includes('art_v2_'), false)
161 assert.equal(events.includes(v2), false)
162 assert.equal(cap2.includes('exact-match-secret-value'), false)
163 assert.equal(cap2err.includes('exact-match-secret-value'), false)
164 assert.equal(events.includes('exact-match-secret-value'), false)
165})
167test('a Secret never appears in an event', async () => {
168 const secret = new Secret('art_v1_NEVER_LOG_THIS_TOKEN')
169 assert.throws(() => JSON.stringify(secret), /Secret cannot be serialized/)
170 const dir = await temp()
171 const runDir = join(dir, 'run')
172 const log = await RunLog.open(runDir, join(dir, 'ledger.jsonl'), 'run-secret')
173 log.conceal('plain-secret-value')
174 await log.noteCommand({
175 argv: ['cf', 'tokens', 'create', secret],
176 cwd: '/workspace',
177 exitCode: 0,
178 durationMs: 3,
179 stdout: `token ${secret.reveal()} and plain-secret-value`,
180 stderr: '',
181 })
182 await assert.rejects(log.error('boom', { leaked: secret }))
183 await log.finish(0, null)
184 const text = await readFile(join(runDir, 'events.jsonl'), 'utf8')
185 const captured = await capture(log, 1, 'stdout')
186 assert.equal(text.includes('art_v1_NEVER_LOG_THIS_TOKEN'), false)
187 assert.equal(text.includes('plain-secret-value'), false)
188 assert.equal(captured.includes('art_v1_NEVER_LOG_THIS_TOKEN'), false)
189 assert.match(text, /<redacted>/)
190 await log.seal()
191})
193test('debrief cites the decision, its rule, and writes charts', async () => {
194 const dir = await temp()
195 const runDir = join(dir, 'run')
196 const log = await RunLog.open(runDir, join(dir, 'ledger.jsonl'), 'run-debrief')
197 await log.started({
198 config: { worker: 'ply' },
199 tools: { node: process.version, cf: 'cf', git: 'git' },
200 plySha: 'abc',
201 plyWebSha: 'def',
202 host: 'box',
203 })
204 const ref = await log.observation({
205 measurement: { source: 'ramp-step', percent: 5, observedPercent: 4, nextWallP99: 90, previousWallP99: 80 },
206 query: { view: 'events', filters: [] },
207 from: 0,
208 to: 1000,
209 raw: '{}',
210 })
211 await log.decision({
212 inputs: [ref],
213 rules: [{ name: 'fast_burn', value: FAST_BURN }],
214 outcome: 'insufficient_data',
215 reason: 'wall samples 3/4; need 20 each for Mann-Whitney or 5 each for a quantile compare',
216 })
217 log.addStep({ percent: 5, burns: { read_latency: 0, availability: null, write_latency: null, correctness: null } })
218 await log.finish(0, null)
219 await log.seal()
220 const markdownPath = await writeDebrief(runDir)
221 const markdown = await readFile(markdownPath, 'utf8')
222 assert.match(markdown, /insufficient_data/)
223 assert.match(markdown, /Informational unless a policy event sets latency to gate/)
224 assert.match(markdown, /fast_burn/)
225 assert.match(markdown, /14\.4/)
226 assert.match(markdown, /blobs\/[0-9a-f]{64}\.gz/)
227 // A clean pass dropped its blobs at seal; the debrief says so instead of linking a missing file.
228 assert.match(markdown, /1 cited capture not kept/)
229 const png = await readFile(join(dir, 'run.debrief', 'burn.png'))
230 assert.equal(png[0], 137)
231 assert.equal(png.subarray(1, 4).toString(), 'PNG')
232 assert.equal(markdown.includes('art_v1_'), false)
233})
235test('dora metrics use run_finished', () => {
236 const finished = (over: Record<string, unknown>): CdEvent => ({
237 seq: 1,
238 ts: '2026-10-31T21:00:00.000+00:00',
239 run_id: 'r',
240 stage: 'run',
241 kind: 'lifecycle',
242 payload: {
243 event: 'run_finished',
244 verdict: 'pass',
245 reason: null,
246 rolledBack: false,
247 rollbackReason: null,
248 versionId: VERSION,
249 plySha: 'a',
250 plyMergedAt: '2026-10-31T20:00:00Z',
251 plyWebSha: 'b',
252 release: null,
253 smoke: { passed: 1, failed: 0 },
254 stages: [{ name: 'bump', startedAt: '2026-10-31T20:00:00.000+00:00', finishedAt: '2026-10-31T20:00:02.000+00:00', durationMs: 2000 }],
255 steps: [],
256 liveAt: '2026-10-31T21:00:00Z',
257 failedAt: null,
258 restoredAt: null,
259 fault: null,
260 ...over,
261 },
262 })
263 const rollback = { ...finished({ rolledBack: true, verdict: 'fail', failedAt: '2026-10-31T22:00:00Z', restoredAt: '2026-10-31T22:01:30Z', liveAt: '2026-11-01T20:50:00Z', plyMergedAt: null }), run_id: 's', ts: '2026-11-01T21:00:00.000+00:00' }
264 const text = doraText([
265 finished({}),
266 rollback,
267 { ...finished({ verdict: 'fail', liveAt: null, rolledBack: false, fault: 'worker', plyMergedAt: null }), run_id: 'held', ts: '2026-11-03T21:00:00.000+00:00' },
268 { ...finished({ fault: 'harness_fault', verdict: 'fail', liveAt: null, rolledBack: false, plyMergedAt: null }), run_id: 'h', ts: '2026-11-04T21:00:00.000+00:00' },
269 { ...finished({ verdict: 'fail', liveAt: null, rolledBack: true, fault: 'worker', failedAt: '2026-11-05T21:00:00Z', restoredAt: '2026-11-05T21:10:00Z', plyMergedAt: null }), run_id: 'aborted', ts: '2026-11-05T21:00:00.000+00:00' },
270 ])
271 assert.match(text, /runs: 5/)
272 assert.match(text, /deploys: 2/)
273 assert.match(text, /excluded from deploys: 3/)
274 assert.match(text, /aborted: 1/)
275 assert.match(text, /held: 1/)
276 assert.match(text, /harness_fault: 1/)
277 assert.match(text, /false_positive: 0/)
278 assert.match(text, /false positives: 0/)
279 assert.match(text, /deployment frequency: 2\.000 \/ day/)
280 assert.match(text, /lead time p50: 3600s/)
281 assert.match(text, /change failure rate: 0\.500/)
282 const withHarness = doraText([
283 finished({}),
284 rollback,
285 { ...finished({ fault: 'harness_fault', rolledBack: true, verdict: 'fail' }), run_id: 'h', ts: '2026-11-02T21:00:00.000+00:00' },
286 ])
287 assert.match(withHarness, /deploys: 2/)
288 assert.match(withHarness, /change failure rate: 0\.500/)
289 assert.match(text, /time to restore p50: 90s/)
290 assert.match(text, /bump p50 2s/)
291 assert.throws(() => validateRun([finished({}), finished({})]))
292})
294test('split.png includes the 0% canary', async () => {
295 const dir = await temp()
296 const runDir = join(dir, 'run')
297 const log = await RunLog.open(runDir, join(dir, 'ledger.jsonl'), 'run-split')
298 await log.stateChange({
299 before: [{ versionId: PREVIOUS, percentage: 100 }],
300 after: [{ versionId: VERSION, percentage: 0 }, { versionId: PREVIOUS, percentage: 100 }],
301 deploymentId: 'dep',
302 })
303 await log.stateChange({
304 before: [{ versionId: VERSION, percentage: 0 }, { versionId: PREVIOUS, percentage: 100 }],
305 after: [{ versionId: VERSION, percentage: 1 }, { versionId: PREVIOUS, percentage: 99 }],
306 deploymentId: 'dep',
307 })
308 await log.finish(0, null)
309 assert.deepEqual(canarySplit(log.recorded()).map(point => point.percent), [0, 1])
310 await log.seal()
311 const markdown = await readFile(await writeDebrief(runDir), 'utf8')
312 assert.match(markdown, /0% canary/)
313})
315test('a false-positive annotation is appended and leaves change failure', async () => {
316 const dir = await temp()
317 const ledger = join(dir, 'ledger.jsonl')
318 const runId = '2026-11-01T00-10-02-620Z'
319 const reason = '5% ramp Mann-Whitney flagged a sub-millisecond wall-time shift'
320 const rollback: CdEvent = {
321 seq: 1,
322 ts: '2026-11-01T00:13:40.000+00:00',
323 run_id: runId,
324 stage: 'run',
325 kind: 'lifecycle',
326 payload: {
327 event: 'run_finished',
328 verdict: 'fail',
329 reason: 'new version wall time is slower',
330 rolledBack: true,
331 rollbackReason: 'new version wall time is slower',
332 versionId: VERSION,
333 plySha: null,
334 plyMergedAt: null,
335 plyWebSha: 'b',
336 release: null,
337 smoke: { passed: 1, failed: 0 },
338 stages: [],
339 steps: [],
340 liveAt: '2026-11-01T00:13:00Z',
341 failedAt: '2026-11-01T00:13:20Z',
342 restoredAt: '2026-11-01T00:13:40Z',
343 fault: 'worker',
344 },
345 }
346 const pass: CdEvent = {
347 seq: 1,
348 ts: '2026-11-02T00:00:00.000+00:00',
349 run_id: '2026-11-02T00-00-00-000Z',
350 stage: 'run',
351 kind: 'lifecycle',
352 payload: {
353 event: 'run_finished',
354 verdict: 'pass',
355 reason: null,
356 rolledBack: false,
357 rollbackReason: null,
358 versionId: VERSION,
359 plySha: null,
360 plyMergedAt: null,
361 plyWebSha: 'b',
362 release: null,
363 smoke: { passed: 1, failed: 0 },
364 stages: [],
365 steps: [],
366 liveAt: '2026-11-02T00:00:00Z',
367 failedAt: null,
368 restoredAt: null,
369 fault: null,
370 },
371 }
372 const before = `${JSON.stringify(rollback)}\n`
373 await writeFile(ledger, before)
374 const noted = await appendFalsePositive(ledger, runId, ` ${reason} `, new Date('2026-11-02T12:00:00Z'))
375 const after = await readFile(ledger, 'utf8')
376 assert.ok(after.startsWith(before))
377 assert.equal(after.split('\n').filter(line => line).length, 2)
378 assert.equal(noted.seq, 2)
379 assert.equal(noted.kind, 'annotation')
380 if (noted.kind === 'annotation') {
381 assert.equal(noted.payload.note, 'false_positive')
382 assert.equal(noted.payload.reason, reason)
383 }
384 const events = after.split('\n').filter(line => line).map(line => parseEvent(JSON.parse(line) as unknown))
385 const text = doraText([...events, pass])
386 assert.match(text, /deploys: 1/)
387 assert.match(text, /false_positive: 1/)
388 assert.match(text, new RegExp(runId))
389 assert.match(text, /change failure rate: 0\.000/)
390 assert.match(text, /0 rollbacks \/ 1 deploys/)
391 const blamed = doraText([rollback, pass])
392 assert.match(blamed, /change failure rate: 0\.500/)
393})
395test('chart png is a png', () => {
396 const png = chartPng({ title: 'burn rate', series: [{ name: 'read', rgb: [1, 2, 3], points: [{ x: '1', y: 2 }] }], hLine: { y: 14.4, rgb: [255, 0, 0] } })
397 assert.equal(png.subarray(0, 4).toString('hex'), '89504e47')
398})
400test('a request names the stage that sent it: a probe inside the live smoke is ramp, the rest take the open stage', async () => {
401 // run 2026-11-10T14-56-52-021Z: the 100% step's 2,001 probes ran beside the live smoke and were logged smoke-live
402 const dir = await temp()
403 const log = await RunLog.open(join(dir, 'run'), join(dir, 'ledger.jsonl'), 'run-stage')
404 log.useStage('smoke-live')
405 const row = { method: 'GET', url: 'https://ply.example/', status: 200, version: VERSION, latencyMs: 5, cfRay: 'a585f4159ae599a2-IAD', requestId: null, artifactsRay: null }
406 await log.request(row, 'ramp')
407 await log.request({ ...row, url: 'https://ply.example/v1/edit', cfRay: 'a585f4159ae599a3-IAD' })
408 const requests = log.recorded().filter(event => event.kind === 'request')
409 assert.deepEqual(requests.map(event => event.stage), ['ramp', 'smoke-live'])
410 await log.finish(0, null)
411})
Diagnostics4 git calls · 201 ms
CallStatusSizeTime0201 ms
discover200152 B4 ms
git.upload-pack discover http.response.status_code=200 git.upstream.cf_ray=- git.upstream.phase=ls-refs git.upstream.dur_ms=4 git.response.bytes=152 git.server.agent=gitty/1.0 git.server.object_format=sha1 git.server.caps=agent ls-refs fetch object-format git.server.fetch=shallow filter sideband-all git.protocol.version=2 git.pkt.frames=8 git.pkt.data=6 git.pkt.flush=2 git.pkt.delim=0 git.pkt.bytes=152 git.pkt.payload.max=34
ls-refs200145 B · hit4 ms
git.upload-pack ls-refs http.response.status_code=200 git.upstream.cf_ray=- git.upstream.phase=ls-refs git.upstream.dur_ms=4 git.response.bytes=145 git.response.cache=HIT git.response.duration_ms=4 git.protocol.version=2 git.pkt.frames=3 git.pkt.data=2 git.pkt.flush=1 git.pkt.delim=0 git.pkt.bytes=145 git.pkt.payload.max=76 git.ls_refs.count=2 git.ls_refs.head=refs/heads/main
fetchblob:none · deepen 1020040 KiB · hit2 ms
git.upload-pack fetch http.response.status_code=200 git.upstream.cf_ray=- git.upstream.phase=fetch git.upstream.dur_ms=2 git.response.bytes=41349 git.response.cache=HIT git.response.duration_ms=2 git.fetch.filter=blob:none git.fetch.filter.requested=tree:0 git.fetch.filter.fallback=blob:none git.fetch.filter.learned=false git.fetch.wants=526b305930b8ef382f2d7a1f9c0238730a585921 git.fetch.haves.count=0 git.fetch.deepen=10 git.fetch.thin_pack=false git.fetch.ofs_delta=true git.protocol.version=2 git.pkt.frames=6 git.pkt.data=4 git.pkt.flush=1 git.pkt.delim=1 git.pkt.bytes=41349 git.pkt.payload.max=41254 git.sideband.band1.bytes=41253 git.sideband.band2.bytes=0 git.sideband.band3.bytes=0 git.pack.objects=61 git.pack.bytes=41253 git.pack.ofs_delta=0 git.pack.ref_delta=0 git.pack.chain.max=0 git.pack.trailer=ab60efef4b7243678c75de64a4386986ee885c1c git.pack.full=61Open pack map
fetch2004.8 KiB195 ms
git.upload-pack fetch http.response.status_code=200 git.upstream.cf_ray=- git.upstream.phase=fetch git.upstream.dur_ms=195 git.response.bytes=4885 git.response.cache=MISS git.response.duration_ms=195 git.fetch.wants=23285aebe983cf12b4eef762a99fb8cda5f22b78 git.fetch.haves.count=0 git.fetch.deepen=0 git.fetch.thin_pack=false git.fetch.ofs_delta=true git.protocol.version=2 git.pkt.frames=3 git.pkt.data=2 git.pkt.flush=1 git.pkt.delim=0 git.pkt.bytes=4885 git.pkt.payload.max=4864 git.sideband.band1.bytes=4863 git.sideband.band2.bytes=0 git.sideband.band3.bytes=0
Each row is one HTTP round trip ply made to the git server for this page, on one timeline. discover asks what the server speaks, ls-refs lists branch tips, fetch brings objects by id. A hit was served by Workers Cache. Tap a row for its wire details.
- Remote
- https://5ad2236b39de4c8bd8f6270ea63f3ea9.artifacts.cloudflare.net/git/public-v0/ply-web.git
- Ref
- refs/heads/main
- Commit
- 526b305930b8ef382f2d7a1f9c0238730a585921
- cf-ray
- a5e2de795afe2308
- Request
- f04a5c32…
- Protocol
- v2 · sha1
- Agent
- gitty/1.0
- Filter
- advertised
- Fetch
- shallow filter sideband-all
- Capabilities
- agent ls-refs fetch object-format