@kitman-sh/sdk 0.10.85 → 0.10.87

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (3) hide show
  1. package/package.json +1 -1
  2. package/types/packages/core/src/run-display.d.ts +1 -1
  3. package/types/packages/live/src/rpc/runner-group.d.ts +1676 -1676
package/types/packages/live/src/rpc/runner-group.d.ts CHANGED
@@ -123,55 +123,24 @@ export declare const ProgramOutcome: Schema.Union<readonly [Schema.Struct<{
123
123
  readonly status: Schema.Literal<"failed">;
124
124
  readonly failureSummary: Schema.String;
125
125
  }>]>;
126
- declare const RunnerReplicaRpcs_base: RpcGroup.RpcGroup<Rpc.Rpc<"AppendTranscript", Schema.Struct<{
127
- workUnitId: Schema.String;
128
- entries: Schema.$Array<Schema.Struct<{
129
- readonly sequence: Schema.Int;
130
- readonly event: Schema.Union<readonly [Schema.Struct<{
131
- readonly kind: Schema.Literal<"message">;
132
- readonly role: Schema.Literals<readonly ["assistant", "user"]>;
133
- readonly text: Schema.String;
134
- }>, Schema.Struct<{
135
- readonly kind: Schema.Literal<"tool_call">;
136
- readonly callId: Schema.String;
137
- readonly name: Schema.String;
138
- readonly arguments: Schema.Codec<Schema.Json, Schema.Json, never, never>;
139
- }>, Schema.Struct<{
140
- readonly kind: Schema.Literal<"tool_result">;
141
- readonly callId: Schema.String;
142
- readonly output: Schema.String;
143
- readonly isError: Schema.optionalKey<Schema.Boolean>;
144
- }>, Schema.Struct<{
145
- readonly kind: Schema.Literal<"file">;
146
- readonly path: Schema.String;
147
- readonly change: Schema.Literals<readonly ["read", "changed"]>;
148
- }>, Schema.Struct<{
149
- readonly kind: Schema.Literal<"question">;
150
- readonly text: Schema.String;
151
- }>, Schema.Struct<{
152
- readonly kind: Schema.Literal<"answer">;
153
- readonly callId: Schema.optionalKey<Schema.String>;
154
- readonly questionId: Schema.optionalKey<Schema.String>;
155
- readonly text: Schema.String;
156
- }>, Schema.Struct<{
157
- readonly kind: Schema.Literal<"steer">;
158
- readonly messageId: Schema.String;
159
- readonly text: Schema.String;
160
- }>, Schema.Struct<{
161
- readonly kind: Schema.Literal<"secret_refused">;
162
- readonly reference: Schema.optionalKey<Schema.String>;
163
- readonly host: Schema.String;
164
- readonly reason: Schema.String;
165
- }>, Schema.Struct<{
166
- readonly kind: Schema.Literal<"lifecycle">;
167
- readonly state: Schema.Literals<readonly ["started", "resumed", "parked", "finished", "failed", "canceled"]>;
168
- }>]>;
126
+ declare const RunnerReplicaRpcs_base: RpcGroup.RpcGroup<Rpc.Rpc<"SettledRuns", Schema.Struct<{
127
+ runIds: Schema.$Array<Schema.String>;
128
+ }>, Schema.$Array<Schema.String>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"SettledCheckpoints", Schema.Void, Schema.$Array<Schema.Struct<{
129
+ readonly stepAttemptId: Schema.String;
130
+ readonly ref: Schema.optionalKey<Schema.String>;
131
+ readonly repoBinding: Schema.optionalKey<Schema.Struct<{
132
+ readonly id: Schema.String;
133
+ readonly provider: Schema.Literals<readonly ["github", "gitlab", "forgejo", "gitea", "gitee", "bitbucket", "azure-devops", "generic_git"]>;
134
+ readonly host: Schema.String;
135
+ readonly owner: Schema.String;
136
+ readonly name: Schema.String;
137
+ readonly repositoryUrl: Schema.optionalKey<Schema.String>;
138
+ readonly pathPrefix: Schema.optionalKey<Schema.String>;
139
+ readonly defaultTargetBranch: Schema.String;
140
+ readonly expectedBranch: Schema.optionalKey<Schema.String>;
141
+ readonly expectedCommitSha: Schema.optionalKey<Schema.String>;
169
142
  }>>;
170
- }>, Schema.Void, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"Bundle", Schema.Struct<{
171
- digest: Schema.String;
172
- }>, Schema.Struct<{
173
- readonly bundle: Schema.String;
174
- }>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"CheckpointFileParts", Schema.Struct<{
143
+ }>>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"KnownEvidence", Schema.Struct<{
175
144
  lease: Schema.Struct<{
176
145
  readonly workUnitId: Schema.String;
177
146
  readonly leaseOwnerId: Schema.String;
@@ -181,16 +150,30 @@ declare const RunnerReplicaRpcs_base: RpcGroup.RpcGroup<Rpc.Rpc<"AppendTranscrip
181
150
  readonly fencingToken: Schema.String;
182
151
  readonly capacitySlot: Schema.String;
183
152
  }>;
184
- fileId: Schema.String;
185
- partNumbers: Schema.$Array<Schema.Int>;
186
- }>, Schema.Struct<{
187
- readonly parts: Schema.$Array<Schema.Struct<{
188
- readonly url: Schema.String;
189
- readonly headers: Schema.optionalKey<Schema.$Record<Schema.String, Schema.String>>;
190
- readonly expiresAt: Schema.String;
191
- readonly partNumber: Schema.Int;
192
- }>>;
193
- }>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"Claim", Schema.Struct<{
153
+ trees: Schema.$Array<Schema.String>;
154
+ }>, Schema.$Array<Schema.Struct<{
155
+ readonly tree: Schema.String;
156
+ readonly name: Schema.String;
157
+ readonly command: Schema.String;
158
+ }>>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"Signals", Schema.Struct<{
159
+ runnerReplicaId: Schema.String;
160
+ }>, import("effect/rpc/RpcSchema").Stream<Schema.Union<readonly [Schema.TaggedStruct<"WorkAvailable", {}>, Schema.TaggedStruct<"LeaseRevoked", {
161
+ readonly workUnitId: Schema.String;
162
+ }>, Schema.TaggedStruct<"Settled", {
163
+ readonly workUnitId: Schema.String;
164
+ }>, Schema.TaggedStruct<"Canceled", {
165
+ readonly workUnitId: Schema.String;
166
+ }>, Schema.TaggedStruct<"RunSettled", {
167
+ readonly runId: Schema.String;
168
+ }>, Schema.TaggedStruct<"Steer", {
169
+ readonly workUnitId: Schema.String;
170
+ readonly messageId: Schema.String;
171
+ readonly text: Schema.String;
172
+ }>, Schema.TaggedStruct<"SessionUpdated", {
173
+ readonly workUnitId: Schema.String;
174
+ }>, Schema.TaggedStruct<"UpdateAvailable", {
175
+ readonly version: Schema.String;
176
+ }>]>, typeof RunnerRpcError>, Schema.Never, typeof RunnerAuthentication, never> | Rpc.Rpc<"Claim", Schema.Struct<{
194
177
  readonly teamId: Schema.optionalKey<Schema.String>;
195
178
  readonly runnerReplicaId: Schema.String;
196
179
  readonly capacitySlot: Schema.String;
@@ -358,7 +341,7 @@ declare const RunnerReplicaRpcs_base: RpcGroup.RpcGroup<Rpc.Rpc<"AppendTranscrip
358
341
  readonly hosts: Schema.optionalKey<Schema.$Array<Schema.String>>;
359
342
  readonly storageOrigin: Schema.optionalKey<Schema.String>;
360
343
  }>]>>;
361
- }>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"Complete", Schema.Struct<{
344
+ }>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"Heartbeat", Schema.Struct<{
362
345
  readonly workUnitId: Schema.String;
363
346
  readonly lease: Schema.Struct<{
364
347
  readonly leaseOwnerId: Schema.String;
@@ -368,113 +351,18 @@ declare const RunnerReplicaRpcs_base: RpcGroup.RpcGroup<Rpc.Rpc<"AppendTranscrip
368
351
  readonly fencingToken: Schema.String;
369
352
  readonly capacitySlot: Schema.String;
370
353
  }>;
371
- readonly idempotencyKey: Schema.String;
372
- readonly outcome: Schema.Struct<{
373
- readonly status: Schema.Union<readonly [Schema.Literal<"completed">, Schema.Literal<"failed">, Schema.Literal<"blocked">, Schema.Literal<"canceled">]>;
374
- readonly result: Schema.optionalKey<Schema.Struct<{
375
- readonly stepKey: Schema.String;
376
- readonly outputSchemaRef: Schema.Struct<{
377
- readonly kind: Schema.Literal<"typebox_ref">;
378
- readonly name: Schema.String;
379
- readonly version: Schema.optionalKey<Schema.String>;
380
- readonly sha256: Schema.optionalKey<Schema.String>;
381
- }>;
382
- readonly summary: Schema.String;
383
- readonly data: Schema.$Record<Schema.String, Schema.Codec<import("../../../core/src/index").LoopStepOutputDataValue, import("../../../core/src/index").LoopStepOutputDataValue, never, never>>;
384
- readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<import("../../../core/src/index").LoopStepOutputDataValue, import("../../../core/src/index").LoopStepOutputDataValue, never, never>>>;
385
- readonly refs: Schema.$Array<Schema.Struct<{
386
- readonly kind: Schema.Literals<readonly ["task", "kit", "memory", "decision", "knowledge_record", "context_pack", "step_attempt", "change_request", "change_request_review", "provider_action", "thread_entry", "run", "artifact"]>;
387
- readonly id: Schema.optionalKey<Schema.String>;
388
- readonly externalId: Schema.optionalKey<Schema.String>;
389
- readonly provider: Schema.optionalKey<Schema.String>;
390
- readonly title: Schema.optionalKey<Schema.String>;
391
- }>>;
392
- }>>;
393
- readonly revision: Schema.optionalKey<Schema.String>;
394
- readonly evidence: Schema.optionalKey<Schema.Struct<{
395
- readonly head: Schema.Struct<{
396
- readonly revision: Schema.String;
397
- readonly tree: Schema.String;
398
- readonly checks: Schema.$Array<Schema.Struct<{
399
- readonly name: Schema.String;
400
- readonly command: Schema.String;
401
- readonly status: Schema.Union<readonly [Schema.Literal<"passed">, Schema.Literal<"failed">]>;
402
- readonly exitCode: Schema.optionalKey<Schema.Int>;
403
- readonly durationMs: Schema.Int;
404
- readonly outputTail: Schema.String;
405
- readonly fileIds: Schema.optionalKey<Schema.$Array<Schema.String>>;
406
- readonly tests: Schema.optionalKey<Schema.Struct<{
407
- readonly reports: Schema.Int;
408
- readonly passed: Schema.Int;
409
- readonly failed: Schema.Int;
410
- readonly skipped: Schema.Int;
411
- readonly skippedTests: Schema.$Array<Schema.String>;
412
- readonly ranDigests: Schema.$Array<Schema.String>;
413
- }>>;
414
- }>>;
415
- }>;
416
- readonly baseline: Schema.optionalKey<Schema.Struct<{
417
- readonly revision: Schema.String;
418
- readonly tree: Schema.String;
419
- readonly checks: Schema.$Array<Schema.Struct<{
420
- readonly name: Schema.String;
421
- readonly command: Schema.String;
422
- readonly status: Schema.Union<readonly [Schema.Literal<"passed">, Schema.Literal<"failed">]>;
423
- readonly exitCode: Schema.optionalKey<Schema.Int>;
424
- readonly durationMs: Schema.Int;
425
- readonly outputTail: Schema.String;
426
- readonly fileIds: Schema.optionalKey<Schema.$Array<Schema.String>>;
427
- readonly tests: Schema.optionalKey<Schema.Struct<{
428
- readonly reports: Schema.Int;
429
- readonly passed: Schema.Int;
430
- readonly failed: Schema.Int;
431
- readonly skipped: Schema.Int;
432
- readonly skippedTests: Schema.$Array<Schema.String>;
433
- readonly ranDigests: Schema.$Array<Schema.String>;
434
- }>>;
435
- }>>;
436
- }>>;
437
- readonly measurement: Schema.optionalKey<Schema.Struct<{
438
- readonly base: Schema.$Array<Schema.$Record<Schema.String, Schema.Finite>>;
439
- readonly head: Schema.$Array<Schema.$Record<Schema.String, Schema.Finite>>;
440
- readonly baseAgain: Schema.optionalKey<Schema.$Array<Schema.$Record<Schema.String, Schema.Finite>>>;
441
- }>>;
442
- readonly resolved: Schema.optionalKey<Schema.Struct<{
443
- readonly commits: Schema.$Array<Schema.String>;
444
- }>>;
445
- }>>;
446
- readonly boundary: Schema.optionalKey<Schema.Struct<{
447
- readonly kind: Schema.Literal<"change">;
448
- readonly changedPaths: Schema.$Array<Schema.String>;
449
- readonly omittedPaths: Schema.Int;
450
- readonly files: Schema.$Array<Schema.Struct<{
451
- readonly path: Schema.String;
452
- readonly excerpt: Schema.String;
453
- readonly redacted: Schema.Boolean;
454
- readonly truncated: Schema.Boolean;
455
- }>>;
456
- readonly truncated: Schema.Boolean;
457
- }>>;
458
- readonly catchUp: Schema.optionalKey<Schema.Struct<{
459
- readonly from: Schema.String;
460
- readonly head: Schema.String;
461
- readonly conflicted: Schema.$Array<Schema.String>;
462
- readonly rewritten: Schema.$Array<Schema.String>;
463
- readonly changed: Schema.$Array<Schema.String>;
464
- readonly truncated: Schema.Boolean;
465
- }>>;
466
- readonly syncedTarget: Schema.optionalKey<Schema.String>;
467
- readonly harnessHold: Schema.optionalKey<Schema.Struct<{
468
- readonly reason: Schema.Literals<readonly ["out_of_quota", "rate_limited", "login_refused", "failed_to_start"]>;
469
- readonly until: Schema.optionalKey<Schema.String>;
470
- readonly scope: Schema.optionalKey<Schema.Literal<"step">>;
471
- }>>;
472
- readonly restart: Schema.optionalKey<Schema.Struct<{
473
- readonly reason: Schema.Literal<"login_revoked">;
474
- }>>;
475
- readonly failureSummary: Schema.optionalKey<Schema.String>;
476
- }>;
477
- }>, Schema.Void, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"CompleteCheckpointFile", Schema.Struct<{
354
+ readonly leaseDurationSeconds: Schema.optionalKey<Schema.Int>;
355
+ readonly secrets: Schema.optionalKey<Schema.$Array<Schema.Struct<{
356
+ readonly name: Schema.String;
357
+ readonly version: Schema.String;
358
+ }>>>;
359
+ }>, Schema.Struct<{
360
+ readonly settled: Schema.Boolean;
361
+ readonly outputSubmitted: Schema.optionalKey<Schema.Boolean>;
362
+ readonly outputMerged: Schema.optionalKey<Schema.Boolean>;
363
+ readonly questionOpen: Schema.optionalKey<Schema.Boolean>;
364
+ readonly revokedSecrets: Schema.optionalKey<Schema.$Array<Schema.String>>;
365
+ }>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"CompleteCheckpointFile", Schema.Struct<{
478
366
  lease: Schema.Struct<{
479
367
  readonly workUnitId: Schema.String;
480
368
  readonly leaseOwnerId: Schema.String;
@@ -540,16 +428,9 @@ declare const RunnerReplicaRpcs_base: RpcGroup.RpcGroup<Rpc.Rpc<"AppendTranscrip
540
428
  readonly partNumber: Schema.Int;
541
429
  }>>;
542
430
  }>]>>;
543
- }>, Schema.Union<readonly [typeof RunnerRpcError, typeof RunFileRefused]>, typeof RunnerAuthentication, never> | Rpc.Rpc<"ForgetCheckpoints", Schema.Struct<{
544
- stepAttemptIds: Schema.$Array<Schema.String>;
545
- }>, Schema.Void, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"GitCredential", Schema.Struct<{
546
- repoBindingId: Schema.String;
547
- }>, Schema.UndefinedOr<Schema.Struct<{
548
- readonly username: Schema.String;
549
- readonly password: Schema.String;
550
- }>>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"Heartbeat", Schema.Struct<{
551
- readonly workUnitId: Schema.String;
552
- readonly lease: Schema.Struct<{
431
+ }>, Schema.Union<readonly [typeof RunnerRpcError, typeof RunFileRefused]>, typeof RunnerAuthentication, never> | Rpc.Rpc<"CheckpointFileParts", Schema.Struct<{
432
+ lease: Schema.Struct<{
433
+ readonly workUnitId: Schema.String;
553
434
  readonly leaseOwnerId: Schema.String;
554
435
  readonly runnerReplicaId: Schema.String;
555
436
  readonly leaseId: Schema.String;
@@ -557,50 +438,20 @@ declare const RunnerReplicaRpcs_base: RpcGroup.RpcGroup<Rpc.Rpc<"AppendTranscrip
557
438
  readonly fencingToken: Schema.String;
558
439
  readonly capacitySlot: Schema.String;
559
440
  }>;
560
- readonly leaseDurationSeconds: Schema.optionalKey<Schema.Int>;
561
- readonly secrets: Schema.optionalKey<Schema.$Array<Schema.Struct<{
562
- readonly name: Schema.String;
563
- readonly version: Schema.String;
564
- }>>>;
441
+ fileId: Schema.String;
442
+ partNumbers: Schema.$Array<Schema.Int>;
565
443
  }>, Schema.Struct<{
566
- readonly settled: Schema.Boolean;
567
- readonly outputSubmitted: Schema.optionalKey<Schema.Boolean>;
568
- readonly outputMerged: Schema.optionalKey<Schema.Boolean>;
569
- readonly questionOpen: Schema.optionalKey<Schema.Boolean>;
570
- readonly revokedSecrets: Schema.optionalKey<Schema.$Array<Schema.String>>;
571
- }>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"KnownEvidence", Schema.Struct<{
572
- lease: Schema.Struct<{
573
- readonly workUnitId: Schema.String;
574
- readonly leaseOwnerId: Schema.String;
575
- readonly runnerReplicaId: Schema.String;
576
- readonly leaseId: Schema.String;
577
- readonly attempt: Schema.Int;
578
- readonly fencingToken: Schema.String;
579
- readonly capacitySlot: Schema.String;
580
- }>;
581
- trees: Schema.$Array<Schema.String>;
582
- }>, Schema.$Array<Schema.Struct<{
583
- readonly tree: Schema.String;
584
- readonly name: Schema.String;
585
- readonly command: Schema.String;
586
- }>>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"Release", Schema.Struct<{
587
- readonly workUnitId: Schema.String;
588
- readonly lease: Schema.Struct<{
589
- readonly leaseOwnerId: Schema.String;
590
- readonly runnerReplicaId: Schema.String;
591
- readonly leaseId: Schema.String;
592
- readonly attempt: Schema.Int;
593
- readonly fencingToken: Schema.String;
594
- readonly capacitySlot: Schema.String;
595
- }>;
596
- readonly crashed: Schema.optionalKey<Schema.Struct<{
597
- readonly reason: Schema.String;
598
- }>>;
599
- }>, Schema.Void, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"ReportSteer", Schema.Struct<{
600
- workUnitId: Schema.String;
601
- messageId: Schema.String;
602
- delivered: Schema.Boolean;
603
- }>, Schema.Void, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"ResumeCheckpoint", Schema.Struct<{
444
+ readonly parts: Schema.$Array<Schema.Struct<{
445
+ readonly url: Schema.String;
446
+ readonly headers: Schema.optionalKey<Schema.$Record<Schema.String, Schema.String>>;
447
+ readonly expiresAt: Schema.String;
448
+ readonly partNumber: Schema.Int;
449
+ }>>;
450
+ }>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"Bundle", Schema.Struct<{
451
+ digest: Schema.String;
452
+ }>, Schema.Struct<{
453
+ readonly bundle: Schema.String;
454
+ }>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"ResumeCheckpoint", Schema.Struct<{
604
455
  lease: Schema.Struct<{
605
456
  readonly workUnitId: Schema.String;
606
457
  readonly leaseOwnerId: Schema.String;
@@ -620,7 +471,191 @@ declare const RunnerReplicaRpcs_base: RpcGroup.RpcGroup<Rpc.Rpc<"AppendTranscrip
620
471
  readonly url: Schema.String;
621
472
  readonly headers: Schema.optionalKey<Schema.$Record<Schema.String, Schema.String>>;
622
473
  }>>;
623
- }>>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"SaveCheckpoint", Schema.Struct<{
474
+ }>>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"GitCredential", Schema.Struct<{
475
+ repoBindingId: Schema.String;
476
+ }>, Schema.UndefinedOr<Schema.Struct<{
477
+ readonly username: Schema.String;
478
+ readonly password: Schema.String;
479
+ }>>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"AppendTranscript", Schema.Struct<{
480
+ workUnitId: Schema.String;
481
+ entries: Schema.$Array<Schema.Struct<{
482
+ readonly sequence: Schema.Int;
483
+ readonly event: Schema.Union<readonly [Schema.Struct<{
484
+ readonly kind: Schema.Literal<"message">;
485
+ readonly role: Schema.Literals<readonly ["assistant", "user"]>;
486
+ readonly text: Schema.String;
487
+ }>, Schema.Struct<{
488
+ readonly kind: Schema.Literal<"tool_call">;
489
+ readonly callId: Schema.String;
490
+ readonly name: Schema.String;
491
+ readonly arguments: Schema.Codec<Schema.Json, Schema.Json, never, never>;
492
+ }>, Schema.Struct<{
493
+ readonly kind: Schema.Literal<"tool_result">;
494
+ readonly callId: Schema.String;
495
+ readonly output: Schema.String;
496
+ readonly isError: Schema.optionalKey<Schema.Boolean>;
497
+ }>, Schema.Struct<{
498
+ readonly kind: Schema.Literal<"file">;
499
+ readonly path: Schema.String;
500
+ readonly change: Schema.Literals<readonly ["read", "changed"]>;
501
+ }>, Schema.Struct<{
502
+ readonly kind: Schema.Literal<"question">;
503
+ readonly text: Schema.String;
504
+ }>, Schema.Struct<{
505
+ readonly kind: Schema.Literal<"answer">;
506
+ readonly callId: Schema.optionalKey<Schema.String>;
507
+ readonly questionId: Schema.optionalKey<Schema.String>;
508
+ readonly text: Schema.String;
509
+ }>, Schema.Struct<{
510
+ readonly kind: Schema.Literal<"steer">;
511
+ readonly messageId: Schema.String;
512
+ readonly text: Schema.String;
513
+ }>, Schema.Struct<{
514
+ readonly kind: Schema.Literal<"secret_refused">;
515
+ readonly reference: Schema.optionalKey<Schema.String>;
516
+ readonly host: Schema.String;
517
+ readonly reason: Schema.String;
518
+ }>, Schema.Struct<{
519
+ readonly kind: Schema.Literal<"lifecycle">;
520
+ readonly state: Schema.Literals<readonly ["started", "resumed", "parked", "finished", "failed", "canceled"]>;
521
+ }>]>;
522
+ }>>;
523
+ }>, Schema.Void, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"Complete", Schema.Struct<{
524
+ readonly workUnitId: Schema.String;
525
+ readonly lease: Schema.Struct<{
526
+ readonly leaseOwnerId: Schema.String;
527
+ readonly runnerReplicaId: Schema.String;
528
+ readonly leaseId: Schema.String;
529
+ readonly attempt: Schema.Int;
530
+ readonly fencingToken: Schema.String;
531
+ readonly capacitySlot: Schema.String;
532
+ }>;
533
+ readonly idempotencyKey: Schema.String;
534
+ readonly outcome: Schema.Struct<{
535
+ readonly status: Schema.Union<readonly [Schema.Literal<"completed">, Schema.Literal<"failed">, Schema.Literal<"blocked">, Schema.Literal<"canceled">]>;
536
+ readonly result: Schema.optionalKey<Schema.Struct<{
537
+ readonly stepKey: Schema.String;
538
+ readonly outputSchemaRef: Schema.Struct<{
539
+ readonly kind: Schema.Literal<"typebox_ref">;
540
+ readonly name: Schema.String;
541
+ readonly version: Schema.optionalKey<Schema.String>;
542
+ readonly sha256: Schema.optionalKey<Schema.String>;
543
+ }>;
544
+ readonly summary: Schema.String;
545
+ readonly data: Schema.$Record<Schema.String, Schema.Codec<import("../../../core/src/index").LoopStepOutputDataValue, import("../../../core/src/index").LoopStepOutputDataValue, never, never>>;
546
+ readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<import("../../../core/src/index").LoopStepOutputDataValue, import("../../../core/src/index").LoopStepOutputDataValue, never, never>>>;
547
+ readonly refs: Schema.$Array<Schema.Struct<{
548
+ readonly kind: Schema.Literals<readonly ["task", "kit", "memory", "decision", "knowledge_record", "context_pack", "step_attempt", "change_request", "change_request_review", "provider_action", "thread_entry", "run", "artifact"]>;
549
+ readonly id: Schema.optionalKey<Schema.String>;
550
+ readonly externalId: Schema.optionalKey<Schema.String>;
551
+ readonly provider: Schema.optionalKey<Schema.String>;
552
+ readonly title: Schema.optionalKey<Schema.String>;
553
+ }>>;
554
+ }>>;
555
+ readonly revision: Schema.optionalKey<Schema.String>;
556
+ readonly evidence: Schema.optionalKey<Schema.Struct<{
557
+ readonly head: Schema.Struct<{
558
+ readonly revision: Schema.String;
559
+ readonly tree: Schema.String;
560
+ readonly checks: Schema.$Array<Schema.Struct<{
561
+ readonly name: Schema.String;
562
+ readonly command: Schema.String;
563
+ readonly status: Schema.Union<readonly [Schema.Literal<"passed">, Schema.Literal<"failed">]>;
564
+ readonly exitCode: Schema.optionalKey<Schema.Int>;
565
+ readonly durationMs: Schema.Int;
566
+ readonly outputTail: Schema.String;
567
+ readonly fileIds: Schema.optionalKey<Schema.$Array<Schema.String>>;
568
+ readonly tests: Schema.optionalKey<Schema.Struct<{
569
+ readonly reports: Schema.Int;
570
+ readonly passed: Schema.Int;
571
+ readonly failed: Schema.Int;
572
+ readonly skipped: Schema.Int;
573
+ readonly skippedTests: Schema.$Array<Schema.String>;
574
+ readonly ranDigests: Schema.$Array<Schema.String>;
575
+ }>>;
576
+ }>>;
577
+ }>;
578
+ readonly baseline: Schema.optionalKey<Schema.Struct<{
579
+ readonly revision: Schema.String;
580
+ readonly tree: Schema.String;
581
+ readonly checks: Schema.$Array<Schema.Struct<{
582
+ readonly name: Schema.String;
583
+ readonly command: Schema.String;
584
+ readonly status: Schema.Union<readonly [Schema.Literal<"passed">, Schema.Literal<"failed">]>;
585
+ readonly exitCode: Schema.optionalKey<Schema.Int>;
586
+ readonly durationMs: Schema.Int;
587
+ readonly outputTail: Schema.String;
588
+ readonly fileIds: Schema.optionalKey<Schema.$Array<Schema.String>>;
589
+ readonly tests: Schema.optionalKey<Schema.Struct<{
590
+ readonly reports: Schema.Int;
591
+ readonly passed: Schema.Int;
592
+ readonly failed: Schema.Int;
593
+ readonly skipped: Schema.Int;
594
+ readonly skippedTests: Schema.$Array<Schema.String>;
595
+ readonly ranDigests: Schema.$Array<Schema.String>;
596
+ }>>;
597
+ }>>;
598
+ }>>;
599
+ readonly measurement: Schema.optionalKey<Schema.Struct<{
600
+ readonly base: Schema.$Array<Schema.$Record<Schema.String, Schema.Finite>>;
601
+ readonly head: Schema.$Array<Schema.$Record<Schema.String, Schema.Finite>>;
602
+ readonly baseAgain: Schema.optionalKey<Schema.$Array<Schema.$Record<Schema.String, Schema.Finite>>>;
603
+ }>>;
604
+ readonly resolved: Schema.optionalKey<Schema.Struct<{
605
+ readonly commits: Schema.$Array<Schema.String>;
606
+ }>>;
607
+ }>>;
608
+ readonly boundary: Schema.optionalKey<Schema.Struct<{
609
+ readonly kind: Schema.Literal<"change">;
610
+ readonly changedPaths: Schema.$Array<Schema.String>;
611
+ readonly omittedPaths: Schema.Int;
612
+ readonly files: Schema.$Array<Schema.Struct<{
613
+ readonly path: Schema.String;
614
+ readonly excerpt: Schema.String;
615
+ readonly redacted: Schema.Boolean;
616
+ readonly truncated: Schema.Boolean;
617
+ }>>;
618
+ readonly truncated: Schema.Boolean;
619
+ }>>;
620
+ readonly catchUp: Schema.optionalKey<Schema.Struct<{
621
+ readonly from: Schema.String;
622
+ readonly head: Schema.String;
623
+ readonly conflicted: Schema.$Array<Schema.String>;
624
+ readonly rewritten: Schema.$Array<Schema.String>;
625
+ readonly changed: Schema.$Array<Schema.String>;
626
+ readonly truncated: Schema.Boolean;
627
+ }>>;
628
+ readonly syncedTarget: Schema.optionalKey<Schema.String>;
629
+ readonly harnessHold: Schema.optionalKey<Schema.Struct<{
630
+ readonly reason: Schema.Literals<readonly ["out_of_quota", "rate_limited", "login_refused", "failed_to_start"]>;
631
+ readonly until: Schema.optionalKey<Schema.String>;
632
+ readonly scope: Schema.optionalKey<Schema.Literal<"step">>;
633
+ }>>;
634
+ readonly restart: Schema.optionalKey<Schema.Struct<{
635
+ readonly reason: Schema.Literal<"login_revoked">;
636
+ }>>;
637
+ readonly failureSummary: Schema.optionalKey<Schema.String>;
638
+ }>;
639
+ }>, Schema.Void, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"ForgetCheckpoints", Schema.Struct<{
640
+ stepAttemptIds: Schema.$Array<Schema.String>;
641
+ }>, Schema.Void, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"Release", Schema.Struct<{
642
+ readonly workUnitId: Schema.String;
643
+ readonly lease: Schema.Struct<{
644
+ readonly leaseOwnerId: Schema.String;
645
+ readonly runnerReplicaId: Schema.String;
646
+ readonly leaseId: Schema.String;
647
+ readonly attempt: Schema.Int;
648
+ readonly fencingToken: Schema.String;
649
+ readonly capacitySlot: Schema.String;
650
+ }>;
651
+ readonly crashed: Schema.optionalKey<Schema.Struct<{
652
+ readonly reason: Schema.String;
653
+ }>>;
654
+ }>, Schema.Void, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"ReportSteer", Schema.Struct<{
655
+ workUnitId: Schema.String;
656
+ messageId: Schema.String;
657
+ delivered: Schema.Boolean;
658
+ }>, Schema.Void, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"SaveCheckpoint", Schema.Struct<{
624
659
  lease: Schema.Struct<{
625
660
  readonly workUnitId: Schema.String;
626
661
  readonly leaseOwnerId: Schema.String;
@@ -640,42 +675,7 @@ declare const RunnerReplicaRpcs_base: RpcGroup.RpcGroup<Rpc.Rpc<"AppendTranscrip
640
675
  readonly fileId: Schema.String;
641
676
  }>>;
642
677
  }>;
643
- }>, Schema.Void, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"SettledCheckpoints", Schema.Void, Schema.$Array<Schema.Struct<{
644
- readonly stepAttemptId: Schema.String;
645
- readonly ref: Schema.optionalKey<Schema.String>;
646
- readonly repoBinding: Schema.optionalKey<Schema.Struct<{
647
- readonly id: Schema.String;
648
- readonly provider: Schema.Literals<readonly ["github", "gitlab", "forgejo", "gitea", "gitee", "bitbucket", "azure-devops", "generic_git"]>;
649
- readonly host: Schema.String;
650
- readonly owner: Schema.String;
651
- readonly name: Schema.String;
652
- readonly repositoryUrl: Schema.optionalKey<Schema.String>;
653
- readonly pathPrefix: Schema.optionalKey<Schema.String>;
654
- readonly defaultTargetBranch: Schema.String;
655
- readonly expectedBranch: Schema.optionalKey<Schema.String>;
656
- readonly expectedCommitSha: Schema.optionalKey<Schema.String>;
657
- }>>;
658
- }>>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"SettledRuns", Schema.Struct<{
659
- runIds: Schema.$Array<Schema.String>;
660
- }>, Schema.$Array<Schema.String>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"Signals", Schema.Struct<{
661
- runnerReplicaId: Schema.String;
662
- }>, import("effect/rpc/RpcSchema").Stream<Schema.Union<readonly [Schema.TaggedStruct<"WorkAvailable", {}>, Schema.TaggedStruct<"LeaseRevoked", {
663
- readonly workUnitId: Schema.String;
664
- }>, Schema.TaggedStruct<"Settled", {
665
- readonly workUnitId: Schema.String;
666
- }>, Schema.TaggedStruct<"Canceled", {
667
- readonly workUnitId: Schema.String;
668
- }>, Schema.TaggedStruct<"RunSettled", {
669
- readonly runId: Schema.String;
670
- }>, Schema.TaggedStruct<"Steer", {
671
- readonly workUnitId: Schema.String;
672
- readonly messageId: Schema.String;
673
- readonly text: Schema.String;
674
- }>, Schema.TaggedStruct<"SessionUpdated", {
675
- readonly workUnitId: Schema.String;
676
- }>, Schema.TaggedStruct<"UpdateAvailable", {
677
- readonly version: Schema.String;
678
- }>]>, typeof RunnerRpcError>, Schema.Never, typeof RunnerAuthentication, never>>;
678
+ }>, Schema.Void, typeof RunnerRpcError, typeof RunnerAuthentication, never>>;
679
679
  /** The Runner process's procedures: Work Unit leases, signals, checkpoints and bundles. */
680
680
  export declare class RunnerReplicaRpcs extends RunnerReplicaRpcs_base {
681
681
  }
@@ -748,7 +748,7 @@ declare const RunnerJournalRpcs_base: RpcGroup.RpcGroup<Rpc.Rpc<"DeferredDone",
748
748
  /** A program's journal: the writes Effect's `WorkflowEngine.Encoded` makes. */
749
749
  export declare class RunnerJournalRpcs extends RunnerJournalRpcs_base {
750
750
  }
751
- declare const RunnerCapabilityRpcs_base: RpcGroup.RpcGroup<Rpc.Rpc<"AdmitChild", Schema.Struct<{
751
+ declare const RunnerCapabilityRpcs_base: RpcGroup.RpcGroup<Rpc.Rpc<"CreatePlanTasks", Schema.Struct<{
752
752
  lease: Schema.Struct<{
753
753
  readonly workUnitId: Schema.String;
754
754
  readonly leaseOwnerId: Schema.String;
@@ -758,15 +758,29 @@ declare const RunnerCapabilityRpcs_base: RpcGroup.RpcGroup<Rpc.Rpc<"AdmitChild",
758
758
  readonly fencingToken: Schema.String;
759
759
  readonly capacitySlot: Schema.String;
760
760
  }>;
761
- step: Schema.String;
762
- loop: Schema.String;
763
- input: Schema.Codec<Schema.Json, Schema.Json, never, never>;
764
- /** Constraints the Child Run's Intent starts with besides its parent's. */
765
- constraints: Schema.optional<Schema.$Array<Schema.String>>;
766
- deferredName: Schema.String;
767
- }>, Schema.Struct<{
768
- readonly runId: Schema.String;
769
- }>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"AlertTask", Schema.Struct<{
761
+ projectId: Schema.optionalKey<Schema.String>;
762
+ tickets: Schema.$Array<Schema.Struct<{
763
+ readonly key: Schema.String;
764
+ readonly title: Schema.String;
765
+ readonly body: Schema.String;
766
+ readonly acceptanceCriteria: Schema.$Array<Schema.String>;
767
+ readonly blockedBy: Schema.$Array<Schema.String>;
768
+ readonly outcome: Schema.optionalKey<Schema.Literals<readonly ["feature", "bug", "refactor", "investigation", "docs", "migration", "performance"]>>;
769
+ }>>;
770
+ }>, Schema.$Array<Schema.Struct<{
771
+ readonly key: Schema.String;
772
+ readonly taskId: Schema.String;
773
+ }>>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"ProgramSecrets", Schema.Struct<{
774
+ lease: Schema.Struct<{
775
+ readonly workUnitId: Schema.String;
776
+ readonly leaseOwnerId: Schema.String;
777
+ readonly runnerReplicaId: Schema.String;
778
+ readonly leaseId: Schema.String;
779
+ readonly attempt: Schema.Int;
780
+ readonly fencingToken: Schema.String;
781
+ readonly capacitySlot: Schema.String;
782
+ }>;
783
+ }>, Schema.$Record<Schema.String, Schema.String>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"PutQuestion", Schema.Struct<{
770
784
  lease: Schema.Struct<{
771
785
  readonly workUnitId: Schema.String;
772
786
  readonly leaseOwnerId: Schema.String;
@@ -777,20 +791,29 @@ declare const RunnerCapabilityRpcs_base: RpcGroup.RpcGroup<Rpc.Rpc<"AdmitChild",
777
791
  readonly capacitySlot: Schema.String;
778
792
  }>;
779
793
  step: Schema.String;
780
- fingerprint: Schema.String;
781
- title: Schema.String;
782
- windowHours: Schema.Int;
783
- resolved: Schema.optionalKey<Schema.Boolean>;
784
- priority: Schema.optionalKey<Schema.Literals<readonly ["urgent", "high", "medium", "low"]>>;
785
- }>, Schema.Struct<{
786
- readonly taskId: Schema.optionalKey<Schema.String>;
787
- readonly created: Schema.Boolean;
788
- readonly resolved: Schema.optionalKey<Schema.Boolean>;
789
- readonly joined: Schema.optionalKey<Schema.Struct<{
790
- readonly kind: Schema.Literals<readonly ["run", "recent"]>;
791
- readonly runId: Schema.String;
794
+ prompt: Schema.String;
795
+ options: Schema.optional<Schema.$Array<Schema.String>>;
796
+ optionDescriptions: Schema.optional<Schema.$Record<Schema.String, Schema.String>>;
797
+ recommended: Schema.optional<Schema.String>;
798
+ recommendationReason: Schema.optional<Schema.String>;
799
+ informationOnly: Schema.optional<Schema.Boolean>;
800
+ /** Approving the Question approves this verification for the Run's repository. */
801
+ verification: Schema.optional<Schema.Struct<{
802
+ readonly name: Schema.String;
803
+ readonly command: Schema.String;
804
+ readonly workingDirectory: Schema.optional<Schema.String>;
792
805
  }>>;
793
- }>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"ApproveChangeRequest", Schema.Struct<{
806
+ /** Taken when the Run is unattended, or when nobody answers within `timeoutMillis`. */
807
+ default: Schema.optional<Schema.String>;
808
+ /** Taken at once when the Run's Team delivers in full auto. */
809
+ auto: Schema.optional<Schema.String>;
810
+ /** Taken at once when the Run's Team delivers in full auto and nobody attends the Run. */
811
+ unattendedAuto: Schema.optional<Schema.String>;
812
+ timeoutMillis: Schema.optional<Schema.Finite>;
813
+ deferredName: Schema.String;
814
+ }>, Schema.Struct<{
815
+ readonly questionId: Schema.String;
816
+ }>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"StartAgentStep", Schema.Struct<{
794
817
  lease: Schema.Struct<{
795
818
  readonly workUnitId: Schema.String;
796
819
  readonly leaseOwnerId: Schema.String;
@@ -801,18 +824,20 @@ declare const RunnerCapabilityRpcs_base: RpcGroup.RpcGroup<Rpc.Rpc<"AdmitChild",
801
824
  readonly capacitySlot: Schema.String;
802
825
  }>;
803
826
  step: Schema.String;
804
- changeRequestId: Schema.String;
805
- head: Schema.String;
806
- summary: Schema.String;
807
- review: Schema.optionalKey<Schema.String>;
808
- carries: Schema.optionalKey<Schema.String>;
809
- }>, Schema.Union<readonly [Schema.Struct<{
810
- readonly approved: Schema.Literal<true>;
811
- readonly reviewId: Schema.String;
827
+ deferredName: Schema.String;
828
+ role: Schema.String;
829
+ agentId: Schema.String;
830
+ prompt: Schema.String;
831
+ /** The skill the Step runs. */
832
+ skill: Schema.optionalKey<Schema.String>;
833
+ outputSchema: Schema.Codec<Schema.Json, Schema.Json, never, never>;
834
+ secrets: Schema.optionalKey<Schema.$Array<Schema.String>>;
835
+ timeoutMillis: Schema.optionalKey<Schema.Int>;
836
+ /** The branch whose head the Runner merges into the checkout before the agent starts. */
837
+ mergeTarget: Schema.optionalKey<Schema.String>;
812
838
  }>, Schema.Struct<{
813
- readonly approved: Schema.Literal<false>;
814
- readonly reason: Schema.String;
815
- }>]>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"AwaitEvent", Schema.Struct<{
839
+ readonly stepAttemptId: Schema.String;
840
+ }>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"StartVerification", Schema.Struct<{
816
841
  lease: Schema.Struct<{
817
842
  readonly workUnitId: Schema.String;
818
843
  readonly leaseOwnerId: Schema.String;
@@ -824,19 +849,43 @@ declare const RunnerCapabilityRpcs_base: RpcGroup.RpcGroup<Rpc.Rpc<"AdmitChild",
824
849
  }>;
825
850
  step: Schema.String;
826
851
  deferredName: Schema.String;
827
- event: Schema.String;
828
- /** Event payload paths and the value, or any of the values, each must hold. */
829
- filter: Schema.optional<Schema.$Record<Schema.String, Schema.Union<readonly [Schema.Union<readonly [Schema.String, Schema.Finite, Schema.Boolean, Schema.Null]>, Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Finite, Schema.Boolean, Schema.Null]>>]>>>;
830
- timeoutMillis: Schema.Int;
831
- /** An ISO time: a state Event received before it never settles the wait, as a newer read superseded it. */
832
- since: Schema.optionalKey<Schema.String>;
833
- /** Other Events that settle the wait too, each with its own filter and `since`. */
834
- or: Schema.optionalKey<Schema.$Array<Schema.Struct<{
835
- readonly event: Schema.String;
836
- readonly filter: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Union<readonly [Schema.Union<readonly [Schema.String, Schema.Finite, Schema.Boolean, Schema.Null]>, Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Finite, Schema.Boolean, Schema.Null]>>]>>>;
837
- readonly since: Schema.optionalKey<Schema.String>;
852
+ /** The Run's head when left out. */
853
+ revision: Schema.optionalKey<Schema.String>;
854
+ checks: Schema.optional<Schema.$Array<Schema.String>>;
855
+ /** Run, labelled as suggested, when the repository has no approved checks. */
856
+ suggested: Schema.optionalKey<Schema.$Array<Schema.Struct<{
857
+ readonly name: Schema.String;
858
+ readonly command: Schema.String;
859
+ readonly workingDirectory: Schema.optionalKey<Schema.String>;
860
+ readonly suggested: Schema.optionalKey<Schema.Boolean>;
838
861
  }>>>;
839
- }>, Schema.Void, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"ClaimResource", Schema.Struct<{
862
+ /** Runs a check again whose evidence at the tree failed, rather than reusing that failure; passed evidence is still reused. */
863
+ rerunFailed: Schema.optionalKey<Schema.Boolean>;
864
+ /** A benchmark against `base` (the Run's base branch head when left out) in place of checks. */
865
+ measure: Schema.optionalKey<Schema.Struct<{
866
+ readonly base: Schema.optionalKey<Schema.String>;
867
+ readonly plan: Schema.Struct<{
868
+ readonly command: Schema.String;
869
+ readonly prepare: Schema.optionalKey<Schema.String>;
870
+ readonly workingDirectory: Schema.optionalKey<Schema.String>;
871
+ readonly warmup: Schema.optionalKey<Schema.Int>;
872
+ readonly metrics: Schema.$Array<Schema.Struct<{
873
+ readonly name: Schema.String;
874
+ readonly direction: Schema.Literals<readonly ["lower", "higher"]>;
875
+ readonly role: Schema.Literals<readonly ["primary", "guardrail"]>;
876
+ readonly lowVariance: Schema.optionalKey<Schema.Boolean>;
877
+ }>>;
878
+ }>;
879
+ readonly samples: Schema.Int;
880
+ readonly calibrate: Schema.Boolean;
881
+ }>>;
882
+ /** Revisions to resolve to commits in place of checks. */
883
+ resolve: Schema.optionalKey<Schema.Struct<{
884
+ readonly revisions: Schema.$Array<Schema.String>;
885
+ }>>;
886
+ }>, Schema.Struct<{
887
+ readonly verificationId: Schema.String;
888
+ }>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"AdmitChild", Schema.Struct<{
840
889
  lease: Schema.Struct<{
841
890
  readonly workUnitId: Schema.String;
842
891
  readonly leaseOwnerId: Schema.String;
@@ -847,10 +896,14 @@ declare const RunnerCapabilityRpcs_base: RpcGroup.RpcGroup<Rpc.Rpc<"AdmitChild",
847
896
  readonly capacitySlot: Schema.String;
848
897
  }>;
849
898
  step: Schema.String;
899
+ loop: Schema.String;
900
+ input: Schema.Codec<Schema.Json, Schema.Json, never, never>;
901
+ /** Constraints the Child Run's Intent starts with besides its parent's. */
902
+ constraints: Schema.optional<Schema.$Array<Schema.String>>;
850
903
  deferredName: Schema.String;
851
- resource: Schema.String;
852
- action: Schema.Literals<readonly ["claim", "take_over", "let_go"]>;
853
- }>, Schema.Void, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"CloseChangeRequest", Schema.Struct<{
904
+ }>, Schema.Struct<{
905
+ readonly runId: Schema.String;
906
+ }>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"StoreArtifact", Schema.Struct<{
854
907
  lease: Schema.Struct<{
855
908
  readonly workUnitId: Schema.String;
856
909
  readonly leaseOwnerId: Schema.String;
@@ -861,13 +914,14 @@ declare const RunnerCapabilityRpcs_base: RpcGroup.RpcGroup<Rpc.Rpc<"AdmitChild",
861
914
  readonly capacitySlot: Schema.String;
862
915
  }>;
863
916
  step: Schema.String;
864
- number: Schema.String;
865
- head: Schema.String;
866
- note: Schema.String;
917
+ kind: Schema.String;
918
+ title: Schema.String;
919
+ text: Schema.String;
920
+ data: Schema.optional<Schema.Codec<Schema.Json, Schema.Json, never, never>>;
921
+ fileIds: Schema.optional<Schema.$Array<Schema.String>>;
867
922
  }>, Schema.Struct<{
868
- readonly closed: Schema.Boolean;
869
- readonly head: Schema.optionalKey<Schema.String>;
870
- }>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"CreatePlanTasks", Schema.Struct<{
923
+ readonly artifactId: Schema.String;
924
+ }>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"AlertTask", Schema.Struct<{
871
925
  lease: Schema.Struct<{
872
926
  readonly workUnitId: Schema.String;
873
927
  readonly leaseOwnerId: Schema.String;
@@ -877,19 +931,21 @@ declare const RunnerCapabilityRpcs_base: RpcGroup.RpcGroup<Rpc.Rpc<"AdmitChild",
877
931
  readonly fencingToken: Schema.String;
878
932
  readonly capacitySlot: Schema.String;
879
933
  }>;
880
- projectId: Schema.optionalKey<Schema.String>;
881
- tickets: Schema.$Array<Schema.Struct<{
882
- readonly key: Schema.String;
883
- readonly title: Schema.String;
884
- readonly body: Schema.String;
885
- readonly acceptanceCriteria: Schema.$Array<Schema.String>;
886
- readonly blockedBy: Schema.$Array<Schema.String>;
887
- readonly outcome: Schema.optionalKey<Schema.Literals<readonly ["feature", "bug", "refactor", "investigation", "docs", "migration", "performance"]>>;
934
+ step: Schema.String;
935
+ fingerprint: Schema.String;
936
+ title: Schema.String;
937
+ windowHours: Schema.Int;
938
+ resolved: Schema.optionalKey<Schema.Boolean>;
939
+ priority: Schema.optionalKey<Schema.Literals<readonly ["urgent", "high", "medium", "low"]>>;
940
+ }>, Schema.Struct<{
941
+ readonly taskId: Schema.optionalKey<Schema.String>;
942
+ readonly created: Schema.Boolean;
943
+ readonly resolved: Schema.optionalKey<Schema.Boolean>;
944
+ readonly joined: Schema.optionalKey<Schema.Struct<{
945
+ readonly kind: Schema.Literals<readonly ["run", "recent"]>;
946
+ readonly runId: Schema.String;
888
947
  }>>;
889
- }>, Schema.$Array<Schema.Struct<{
890
- readonly key: Schema.String;
891
- readonly taskId: Schema.String;
892
- }>>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"DraftUpdate", Schema.Struct<{
948
+ }>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"ReadTranscripts", Schema.Struct<{
893
949
  lease: Schema.Struct<{
894
950
  readonly workUnitId: Schema.String;
895
951
  readonly leaseOwnerId: Schema.String;
@@ -900,17 +956,23 @@ declare const RunnerCapabilityRpcs_base: RpcGroup.RpcGroup<Rpc.Rpc<"AdmitChild",
900
956
  readonly capacitySlot: Schema.String;
901
957
  }>;
902
958
  step: Schema.String;
903
- projectId: Schema.String;
904
- health: Schema.Literals<readonly ["on_track", "at_risk", "off_track"]>;
905
- note: Schema.String;
906
- writtenFrom: Schema.Struct<{
907
- readonly runs: Schema.Int;
908
- readonly taskChanges: Schema.Int;
909
- readonly since: Schema.optionalKey<Schema.String>;
910
- }>;
959
+ days: Schema.Int;
911
960
  }>, Schema.Struct<{
912
- readonly id: Schema.String;
913
- }>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"IntegrationBranch", Schema.Struct<{
961
+ readonly runs: Schema.$Array<Schema.Struct<{
962
+ readonly runId: Schema.String;
963
+ readonly loopId: Schema.String;
964
+ readonly status: Schema.optionalKey<Schema.Literals<readonly ["completed", "failed", "canceled", "expired"]>>;
965
+ readonly teamId: Schema.optionalKey<Schema.String>;
966
+ readonly failure: Schema.optionalKey<Schema.String>;
967
+ readonly retried: Schema.optionalKey<Schema.Boolean>;
968
+ readonly entries: Schema.$Array<Schema.Struct<{
969
+ readonly stepAttemptId: Schema.String;
970
+ readonly sequence: Schema.Int;
971
+ readonly kind: Schema.String;
972
+ readonly text: Schema.String;
973
+ }>>;
974
+ }>>;
975
+ }>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"PipelineStatus", Schema.Struct<{
914
976
  lease: Schema.Struct<{
915
977
  readonly workUnitId: Schema.String;
916
978
  readonly leaseOwnerId: Schema.String;
@@ -920,12 +982,36 @@ declare const RunnerCapabilityRpcs_base: RpcGroup.RpcGroup<Rpc.Rpc<"AdmitChild",
920
982
  readonly fencingToken: Schema.String;
921
983
  readonly capacitySlot: Schema.String;
922
984
  }>;
923
- repoBindingId: Schema.optionalKey<Schema.String>;
985
+ step: Schema.String;
986
+ changeRequestId: Schema.String;
924
987
  }>, Schema.Struct<{
925
- readonly repoBindingId: Schema.String;
926
- readonly branch: Schema.String;
927
- readonly revision: Schema.String;
928
- }>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"MergeChangeRequest", Schema.Struct<{
988
+ readonly head: Schema.String;
989
+ readonly status: Schema.Literals<readonly ["none", "running", "success", "failed", "canceled"]>;
990
+ readonly source: Schema.Literals<readonly ["forge", "reported"]>;
991
+ readonly jobs: Schema.$Array<Schema.Struct<{
992
+ readonly name: Schema.String;
993
+ readonly status: Schema.Literals<readonly ["running", "success", "failed", "skipped"]>;
994
+ readonly url: Schema.optionalKey<Schema.String>;
995
+ readonly logTail: Schema.optionalKey<Schema.String>;
996
+ }>>;
997
+ readonly readAt: Schema.optionalKey<Schema.String>;
998
+ readonly runnerChecks: Schema.optionalKey<Schema.$Array<Schema.String>>;
999
+ readonly approved: Schema.optionalKey<Schema.String>;
1000
+ readonly repository: Schema.optionalKey<Schema.String>;
1001
+ readonly targetBranch: Schema.optionalKey<Schema.String>;
1002
+ readonly conflicts: Schema.optionalKey<Schema.Boolean>;
1003
+ readonly needsRebase: Schema.optionalKey<Schema.Boolean>;
1004
+ readonly target: Schema.optionalKey<Schema.Struct<{
1005
+ readonly branch: Schema.String;
1006
+ readonly head: Schema.String;
1007
+ readonly jobs: Schema.$Array<Schema.Struct<{
1008
+ readonly name: Schema.String;
1009
+ readonly status: Schema.Literals<readonly ["running", "success", "failed", "skipped"]>;
1010
+ readonly url: Schema.optionalKey<Schema.String>;
1011
+ readonly logTail: Schema.optionalKey<Schema.String>;
1012
+ }>>;
1013
+ }>>;
1014
+ }>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"ReportPipeline", Schema.Struct<{
929
1015
  lease: Schema.Struct<{
930
1016
  readonly workUnitId: Schema.String;
931
1017
  readonly leaseOwnerId: Schema.String;
@@ -937,16 +1023,34 @@ declare const RunnerCapabilityRpcs_base: RpcGroup.RpcGroup<Rpc.Rpc<"AdmitChild",
937
1023
  }>;
938
1024
  step: Schema.String;
939
1025
  changeRequestId: Schema.String;
940
- head: Schema.optionalKey<Schema.String>;
941
- }>, Schema.Union<readonly [Schema.Struct<{
942
- readonly status: Schema.Literal<"merged">;
943
- readonly revision: Schema.String;
944
- }>, Schema.Struct<{
945
- readonly status: Schema.Literal<"conflict">;
1026
+ verification: Schema.String;
946
1027
  }>, Schema.Struct<{
947
- readonly status: Schema.Literal<"moved">;
948
1028
  readonly head: Schema.String;
949
- }>]>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"OpenChangeRequests", Schema.Struct<{
1029
+ readonly status: Schema.Literals<readonly ["success", "failed"]>;
1030
+ }>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"ReviewThreads", Schema.Struct<{
1031
+ lease: Schema.Struct<{
1032
+ readonly workUnitId: Schema.String;
1033
+ readonly leaseOwnerId: Schema.String;
1034
+ readonly runnerReplicaId: Schema.String;
1035
+ readonly leaseId: Schema.String;
1036
+ readonly attempt: Schema.Int;
1037
+ readonly fencingToken: Schema.String;
1038
+ readonly capacitySlot: Schema.String;
1039
+ }>;
1040
+ step: Schema.String;
1041
+ changeRequestId: Schema.String;
1042
+ }>, Schema.Struct<{
1043
+ readonly threads: Schema.$Array<Schema.Struct<{
1044
+ readonly id: Schema.String;
1045
+ readonly path: Schema.optionalKey<Schema.String>;
1046
+ readonly line: Schema.optionalKey<Schema.Int>;
1047
+ readonly outdated: Schema.optionalKey<Schema.Boolean>;
1048
+ readonly comments: Schema.$Array<Schema.Struct<{
1049
+ readonly author: Schema.optionalKey<Schema.String>;
1050
+ readonly body: Schema.String;
1051
+ }>>;
1052
+ }>>;
1053
+ }>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"OpenChangeRequests", Schema.Struct<{
950
1054
  lease: Schema.Struct<{
951
1055
  readonly workUnitId: Schema.String;
952
1056
  readonly leaseOwnerId: Schema.String;
@@ -988,92 +1092,7 @@ declare const RunnerCapabilityRpcs_base: RpcGroup.RpcGroup<Rpc.Rpc<"AdmitChild",
988
1092
  readonly sourceBranch: Schema.String;
989
1093
  readonly body: Schema.String;
990
1094
  }>>;
991
- }>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"PerformHostEffect", Schema.Struct<{
992
- lease: Schema.Struct<{
993
- readonly workUnitId: Schema.String;
994
- readonly leaseOwnerId: Schema.String;
995
- readonly runnerReplicaId: Schema.String;
996
- readonly leaseId: Schema.String;
997
- readonly attempt: Schema.Int;
998
- readonly fencingToken: Schema.String;
999
- readonly capacitySlot: Schema.String;
1000
- }>;
1001
- step: Schema.String;
1002
- effect: Schema.Union<readonly [Schema.Struct<{
1003
- readonly kind: Schema.Literal<"post_comment">;
1004
- readonly changeRequestId: Schema.String;
1005
- readonly body: Schema.String;
1006
- readonly threadId: Schema.optionalKey<Schema.String>;
1007
- readonly summary: Schema.optionalKey<Schema.String>;
1008
- readonly anchors: Schema.optionalKey<Schema.$Array<Schema.Struct<{
1009
- readonly file: Schema.String;
1010
- readonly line: Schema.Int;
1011
- readonly body: Schema.String;
1012
- }>>>;
1013
- }>, Schema.Struct<{
1014
- readonly kind: Schema.Literal<"change_request">;
1015
- readonly title: Schema.String;
1016
- readonly body: Schema.String;
1017
- readonly integration: Schema.optionalKey<Schema.String>;
1018
- }>, Schema.Struct<{
1019
- readonly kind: Schema.Literal<"write_back">;
1020
- readonly milestone: Schema.optionalKey<Schema.Literals<readonly ["started", "change_request_opened", "merged", "failed"]>>;
1021
- readonly changeRequestUrl: Schema.optionalKey<Schema.String>;
1022
- }>]>;
1023
- }>, Schema.UndefinedOr<Schema.Struct<{
1024
- readonly id: Schema.String;
1025
- readonly number: Schema.String;
1026
- readonly url: Schema.String;
1027
- }>>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"PipelineStatus", Schema.Struct<{
1028
- lease: Schema.Struct<{
1029
- readonly workUnitId: Schema.String;
1030
- readonly leaseOwnerId: Schema.String;
1031
- readonly runnerReplicaId: Schema.String;
1032
- readonly leaseId: Schema.String;
1033
- readonly attempt: Schema.Int;
1034
- readonly fencingToken: Schema.String;
1035
- readonly capacitySlot: Schema.String;
1036
- }>;
1037
- step: Schema.String;
1038
- changeRequestId: Schema.String;
1039
- }>, Schema.Struct<{
1040
- readonly head: Schema.String;
1041
- readonly status: Schema.Literals<readonly ["none", "running", "success", "failed", "canceled"]>;
1042
- readonly source: Schema.Literals<readonly ["forge", "reported"]>;
1043
- readonly jobs: Schema.$Array<Schema.Struct<{
1044
- readonly name: Schema.String;
1045
- readonly status: Schema.Literals<readonly ["running", "success", "failed", "skipped"]>;
1046
- readonly url: Schema.optionalKey<Schema.String>;
1047
- readonly logTail: Schema.optionalKey<Schema.String>;
1048
- }>>;
1049
- readonly readAt: Schema.optionalKey<Schema.String>;
1050
- readonly runnerChecks: Schema.optionalKey<Schema.$Array<Schema.String>>;
1051
- readonly approved: Schema.optionalKey<Schema.String>;
1052
- readonly repository: Schema.optionalKey<Schema.String>;
1053
- readonly targetBranch: Schema.optionalKey<Schema.String>;
1054
- readonly conflicts: Schema.optionalKey<Schema.Boolean>;
1055
- readonly needsRebase: Schema.optionalKey<Schema.Boolean>;
1056
- readonly target: Schema.optionalKey<Schema.Struct<{
1057
- readonly branch: Schema.String;
1058
- readonly head: Schema.String;
1059
- readonly jobs: Schema.$Array<Schema.Struct<{
1060
- readonly name: Schema.String;
1061
- readonly status: Schema.Literals<readonly ["running", "success", "failed", "skipped"]>;
1062
- readonly url: Schema.optionalKey<Schema.String>;
1063
- readonly logTail: Schema.optionalKey<Schema.String>;
1064
- }>>;
1065
- }>>;
1066
- }>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"ProgramSecrets", Schema.Struct<{
1067
- lease: Schema.Struct<{
1068
- readonly workUnitId: Schema.String;
1069
- readonly leaseOwnerId: Schema.String;
1070
- readonly runnerReplicaId: Schema.String;
1071
- readonly leaseId: Schema.String;
1072
- readonly attempt: Schema.Int;
1073
- readonly fencingToken: Schema.String;
1074
- readonly capacitySlot: Schema.String;
1075
- }>;
1076
- }>, Schema.$Record<Schema.String, Schema.String>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"Propose", Schema.Struct<{
1095
+ }>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"Propose", Schema.Struct<{
1077
1096
  lease: Schema.Struct<{
1078
1097
  readonly workUnitId: Schema.String;
1079
1098
  readonly leaseOwnerId: Schema.String;
@@ -1109,58 +1128,6 @@ declare const RunnerCapabilityRpcs_base: RpcGroup.RpcGroup<Rpc.Rpc<"AdmitChild",
1109
1128
  readonly kind: Schema.Literals<readonly ["memory", "task"]>;
1110
1129
  readonly id: Schema.String;
1111
1130
  readonly matched: Schema.optionalKey<Schema.Boolean>;
1112
- }>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"PublishRelease", Schema.Struct<{
1113
- lease: Schema.Struct<{
1114
- readonly workUnitId: Schema.String;
1115
- readonly leaseOwnerId: Schema.String;
1116
- readonly runnerReplicaId: Schema.String;
1117
- readonly leaseId: Schema.String;
1118
- readonly attempt: Schema.Int;
1119
- readonly fencingToken: Schema.String;
1120
- readonly capacitySlot: Schema.String;
1121
- }>;
1122
- step: Schema.String;
1123
- tag: Schema.String;
1124
- revision: Schema.optionalKey<Schema.String>;
1125
- title: Schema.String;
1126
- notes: Schema.String;
1127
- }>, Schema.Struct<{
1128
- readonly tag: Schema.String;
1129
- readonly revision: Schema.String;
1130
- readonly url: Schema.String;
1131
- }>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"PutQuestion", Schema.Struct<{
1132
- lease: Schema.Struct<{
1133
- readonly workUnitId: Schema.String;
1134
- readonly leaseOwnerId: Schema.String;
1135
- readonly runnerReplicaId: Schema.String;
1136
- readonly leaseId: Schema.String;
1137
- readonly attempt: Schema.Int;
1138
- readonly fencingToken: Schema.String;
1139
- readonly capacitySlot: Schema.String;
1140
- }>;
1141
- step: Schema.String;
1142
- prompt: Schema.String;
1143
- options: Schema.optional<Schema.$Array<Schema.String>>;
1144
- optionDescriptions: Schema.optional<Schema.$Record<Schema.String, Schema.String>>;
1145
- recommended: Schema.optional<Schema.String>;
1146
- recommendationReason: Schema.optional<Schema.String>;
1147
- informationOnly: Schema.optional<Schema.Boolean>;
1148
- /** Approving the Question approves this verification for the Run's repository. */
1149
- verification: Schema.optional<Schema.Struct<{
1150
- readonly name: Schema.String;
1151
- readonly command: Schema.String;
1152
- readonly workingDirectory: Schema.optional<Schema.String>;
1153
- }>>;
1154
- /** Taken when the Run is unattended, or when nobody answers within `timeoutMillis`. */
1155
- default: Schema.optional<Schema.String>;
1156
- /** Taken at once when the Run's Team delivers in full auto. */
1157
- auto: Schema.optional<Schema.String>;
1158
- /** Taken at once when the Run's Team delivers in full auto and nobody attends the Run. */
1159
- unattendedAuto: Schema.optional<Schema.String>;
1160
- timeoutMillis: Schema.optional<Schema.Finite>;
1161
- deferredName: Schema.String;
1162
- }>, Schema.Struct<{
1163
- readonly questionId: Schema.String;
1164
1131
  }>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"ReadProject", Schema.Struct<{
1165
1132
  lease: Schema.Struct<{
1166
1133
  readonly workUnitId: Schema.String;
@@ -1200,7 +1167,7 @@ declare const RunnerCapabilityRpcs_base: RpcGroup.RpcGroup<Rpc.Rpc<"AdmitChild",
1200
1167
  readonly change: Schema.String;
1201
1168
  readonly at: Schema.String;
1202
1169
  }>>;
1203
- }>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"ReadTranscripts", Schema.Struct<{
1170
+ }>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"DraftUpdate", Schema.Struct<{
1204
1171
  lease: Schema.Struct<{
1205
1172
  readonly workUnitId: Schema.String;
1206
1173
  readonly leaseOwnerId: Schema.String;
@@ -1211,23 +1178,17 @@ declare const RunnerCapabilityRpcs_base: RpcGroup.RpcGroup<Rpc.Rpc<"AdmitChild",
1211
1178
  readonly capacitySlot: Schema.String;
1212
1179
  }>;
1213
1180
  step: Schema.String;
1214
- days: Schema.Int;
1181
+ projectId: Schema.String;
1182
+ health: Schema.Literals<readonly ["on_track", "at_risk", "off_track"]>;
1183
+ note: Schema.String;
1184
+ writtenFrom: Schema.Struct<{
1185
+ readonly runs: Schema.Int;
1186
+ readonly taskChanges: Schema.Int;
1187
+ readonly since: Schema.optionalKey<Schema.String>;
1188
+ }>;
1215
1189
  }>, Schema.Struct<{
1216
- readonly runs: Schema.$Array<Schema.Struct<{
1217
- readonly runId: Schema.String;
1218
- readonly loopId: Schema.String;
1219
- readonly status: Schema.optionalKey<Schema.Literals<readonly ["completed", "failed", "canceled", "expired"]>>;
1220
- readonly teamId: Schema.optionalKey<Schema.String>;
1221
- readonly failure: Schema.optionalKey<Schema.String>;
1222
- readonly retried: Schema.optionalKey<Schema.Boolean>;
1223
- readonly entries: Schema.$Array<Schema.Struct<{
1224
- readonly stepAttemptId: Schema.String;
1225
- readonly sequence: Schema.Int;
1226
- readonly kind: Schema.String;
1227
- readonly text: Schema.String;
1228
- }>>;
1229
- }>>;
1230
- }>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"RecordNote", Schema.Struct<{
1190
+ readonly id: Schema.String;
1191
+ }>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"IntegrationBranch", Schema.Struct<{
1231
1192
  lease: Schema.Struct<{
1232
1193
  readonly workUnitId: Schema.String;
1233
1194
  readonly leaseOwnerId: Schema.String;
@@ -1237,12 +1198,12 @@ declare const RunnerCapabilityRpcs_base: RpcGroup.RpcGroup<Rpc.Rpc<"AdmitChild",
1237
1198
  readonly fencingToken: Schema.String;
1238
1199
  readonly capacitySlot: Schema.String;
1239
1200
  }>;
1240
- step: Schema.String;
1241
- text: Schema.String;
1242
- artifactId: Schema.optional<Schema.String>;
1243
- /** A `blocker` records what the Task waits on; a note when left out. */
1244
- kind: Schema.optional<Schema.Literals<readonly ["note", "blocker"]>>;
1245
- }>, Schema.Void, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"ReportPipeline", Schema.Struct<{
1201
+ repoBindingId: Schema.optionalKey<Schema.String>;
1202
+ }>, Schema.Struct<{
1203
+ readonly repoBindingId: Schema.String;
1204
+ readonly branch: Schema.String;
1205
+ readonly revision: Schema.String;
1206
+ }>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"CloseChangeRequest", Schema.Struct<{
1246
1207
  lease: Schema.Struct<{
1247
1208
  readonly workUnitId: Schema.String;
1248
1209
  readonly leaseOwnerId: Schema.String;
@@ -1253,11 +1214,12 @@ declare const RunnerCapabilityRpcs_base: RpcGroup.RpcGroup<Rpc.Rpc<"AdmitChild",
1253
1214
  readonly capacitySlot: Schema.String;
1254
1215
  }>;
1255
1216
  step: Schema.String;
1256
- changeRequestId: Schema.String;
1257
- verification: Schema.String;
1217
+ number: Schema.String;
1218
+ head: Schema.String;
1219
+ note: Schema.String;
1258
1220
  }>, Schema.Struct<{
1259
- readonly head: Schema.String;
1260
- readonly status: Schema.Literals<readonly ["success", "failed"]>;
1221
+ readonly closed: Schema.Boolean;
1222
+ readonly head: Schema.optionalKey<Schema.String>;
1261
1223
  }>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"RerunPipeline", Schema.Struct<{
1262
1224
  lease: Schema.Struct<{
1263
1225
  readonly workUnitId: Schema.String;
@@ -1275,7 +1237,7 @@ declare const RunnerCapabilityRpcs_base: RpcGroup.RpcGroup<Rpc.Rpc<"AdmitChild",
1275
1237
  }>, Schema.Struct<{
1276
1238
  readonly head: Schema.String;
1277
1239
  readonly pipelines: Schema.Int;
1278
- }>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"ReviewThreads", Schema.Struct<{
1240
+ }>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"PublishRelease", Schema.Struct<{
1279
1241
  lease: Schema.Struct<{
1280
1242
  readonly workUnitId: Schema.String;
1281
1243
  readonly leaseOwnerId: Schema.String;
@@ -1286,19 +1248,51 @@ declare const RunnerCapabilityRpcs_base: RpcGroup.RpcGroup<Rpc.Rpc<"AdmitChild",
1286
1248
  readonly capacitySlot: Schema.String;
1287
1249
  }>;
1288
1250
  step: Schema.String;
1289
- changeRequestId: Schema.String;
1251
+ tag: Schema.String;
1252
+ revision: Schema.optionalKey<Schema.String>;
1253
+ title: Schema.String;
1254
+ notes: Schema.String;
1290
1255
  }>, Schema.Struct<{
1291
- readonly threads: Schema.$Array<Schema.Struct<{
1292
- readonly id: Schema.String;
1293
- readonly path: Schema.optionalKey<Schema.String>;
1294
- readonly line: Schema.optionalKey<Schema.Int>;
1295
- readonly outdated: Schema.optionalKey<Schema.Boolean>;
1296
- readonly comments: Schema.$Array<Schema.Struct<{
1297
- readonly author: Schema.optionalKey<Schema.String>;
1256
+ readonly tag: Schema.String;
1257
+ readonly revision: Schema.String;
1258
+ readonly url: Schema.String;
1259
+ }>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"PerformHostEffect", Schema.Struct<{
1260
+ lease: Schema.Struct<{
1261
+ readonly workUnitId: Schema.String;
1262
+ readonly leaseOwnerId: Schema.String;
1263
+ readonly runnerReplicaId: Schema.String;
1264
+ readonly leaseId: Schema.String;
1265
+ readonly attempt: Schema.Int;
1266
+ readonly fencingToken: Schema.String;
1267
+ readonly capacitySlot: Schema.String;
1268
+ }>;
1269
+ step: Schema.String;
1270
+ effect: Schema.Union<readonly [Schema.Struct<{
1271
+ readonly kind: Schema.Literal<"post_comment">;
1272
+ readonly changeRequestId: Schema.String;
1273
+ readonly body: Schema.String;
1274
+ readonly threadId: Schema.optionalKey<Schema.String>;
1275
+ readonly summary: Schema.optionalKey<Schema.String>;
1276
+ readonly anchors: Schema.optionalKey<Schema.$Array<Schema.Struct<{
1277
+ readonly file: Schema.String;
1278
+ readonly line: Schema.Int;
1298
1279
  readonly body: Schema.String;
1299
- }>>;
1300
- }>>;
1301
- }>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"StartAgentStep", Schema.Struct<{
1280
+ }>>>;
1281
+ }>, Schema.Struct<{
1282
+ readonly kind: Schema.Literal<"change_request">;
1283
+ readonly title: Schema.String;
1284
+ readonly body: Schema.String;
1285
+ readonly integration: Schema.optionalKey<Schema.String>;
1286
+ }>, Schema.Struct<{
1287
+ readonly kind: Schema.Literal<"write_back">;
1288
+ readonly milestone: Schema.optionalKey<Schema.Literals<readonly ["started", "change_request_opened", "merged", "failed"]>>;
1289
+ readonly changeRequestUrl: Schema.optionalKey<Schema.String>;
1290
+ }>]>;
1291
+ }>, Schema.UndefinedOr<Schema.Struct<{
1292
+ readonly id: Schema.String;
1293
+ readonly number: Schema.String;
1294
+ readonly url: Schema.String;
1295
+ }>>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"ApproveChangeRequest", Schema.Struct<{
1302
1296
  lease: Schema.Struct<{
1303
1297
  readonly workUnitId: Schema.String;
1304
1298
  readonly leaseOwnerId: Schema.String;
@@ -1309,20 +1303,18 @@ declare const RunnerCapabilityRpcs_base: RpcGroup.RpcGroup<Rpc.Rpc<"AdmitChild",
1309
1303
  readonly capacitySlot: Schema.String;
1310
1304
  }>;
1311
1305
  step: Schema.String;
1312
- deferredName: Schema.String;
1313
- role: Schema.String;
1314
- agentId: Schema.String;
1315
- prompt: Schema.String;
1316
- /** The skill the Step runs. */
1317
- skill: Schema.optionalKey<Schema.String>;
1318
- outputSchema: Schema.Codec<Schema.Json, Schema.Json, never, never>;
1319
- secrets: Schema.optionalKey<Schema.$Array<Schema.String>>;
1320
- timeoutMillis: Schema.optionalKey<Schema.Int>;
1321
- /** The branch whose head the Runner merges into the checkout before the agent starts. */
1322
- mergeTarget: Schema.optionalKey<Schema.String>;
1306
+ changeRequestId: Schema.String;
1307
+ head: Schema.String;
1308
+ summary: Schema.String;
1309
+ review: Schema.optionalKey<Schema.String>;
1310
+ carries: Schema.optionalKey<Schema.String>;
1311
+ }>, Schema.Union<readonly [Schema.Struct<{
1312
+ readonly approved: Schema.Literal<true>;
1313
+ readonly reviewId: Schema.String;
1323
1314
  }>, Schema.Struct<{
1324
- readonly stepAttemptId: Schema.String;
1325
- }>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"StartVerification", Schema.Struct<{
1315
+ readonly approved: Schema.Literal<false>;
1316
+ readonly reason: Schema.String;
1317
+ }>]>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"MergeChangeRequest", Schema.Struct<{
1326
1318
  lease: Schema.Struct<{
1327
1319
  readonly workUnitId: Schema.String;
1328
1320
  readonly leaseOwnerId: Schema.String;
@@ -1333,44 +1325,55 @@ declare const RunnerCapabilityRpcs_base: RpcGroup.RpcGroup<Rpc.Rpc<"AdmitChild",
1333
1325
  readonly capacitySlot: Schema.String;
1334
1326
  }>;
1335
1327
  step: Schema.String;
1336
- deferredName: Schema.String;
1337
- /** The Run's head when left out. */
1338
- revision: Schema.optionalKey<Schema.String>;
1339
- checks: Schema.optional<Schema.$Array<Schema.String>>;
1340
- /** Run, labelled as suggested, when the repository has no approved checks. */
1341
- suggested: Schema.optionalKey<Schema.$Array<Schema.Struct<{
1342
- readonly name: Schema.String;
1343
- readonly command: Schema.String;
1344
- readonly workingDirectory: Schema.optionalKey<Schema.String>;
1345
- readonly suggested: Schema.optionalKey<Schema.Boolean>;
1346
- }>>>;
1347
- /** Runs a check again whose evidence at the tree failed, rather than reusing that failure; passed evidence is still reused. */
1348
- rerunFailed: Schema.optionalKey<Schema.Boolean>;
1349
- /** A benchmark against `base` (the Run's base branch head when left out) in place of checks. */
1350
- measure: Schema.optionalKey<Schema.Struct<{
1351
- readonly base: Schema.optionalKey<Schema.String>;
1352
- readonly plan: Schema.Struct<{
1353
- readonly command: Schema.String;
1354
- readonly prepare: Schema.optionalKey<Schema.String>;
1355
- readonly workingDirectory: Schema.optionalKey<Schema.String>;
1356
- readonly warmup: Schema.optionalKey<Schema.Int>;
1357
- readonly metrics: Schema.$Array<Schema.Struct<{
1358
- readonly name: Schema.String;
1359
- readonly direction: Schema.Literals<readonly ["lower", "higher"]>;
1360
- readonly role: Schema.Literals<readonly ["primary", "guardrail"]>;
1361
- readonly lowVariance: Schema.optionalKey<Schema.Boolean>;
1362
- }>>;
1363
- }>;
1364
- readonly samples: Schema.Int;
1365
- readonly calibrate: Schema.Boolean;
1366
- }>>;
1367
- /** Revisions to resolve to commits in place of checks. */
1368
- resolve: Schema.optionalKey<Schema.Struct<{
1369
- readonly revisions: Schema.$Array<Schema.String>;
1370
- }>>;
1328
+ changeRequestId: Schema.String;
1329
+ head: Schema.optionalKey<Schema.String>;
1330
+ }>, Schema.Union<readonly [Schema.Struct<{
1331
+ readonly status: Schema.Literal<"merged">;
1332
+ readonly revision: Schema.String;
1371
1333
  }>, Schema.Struct<{
1372
- readonly verificationId: Schema.String;
1373
- }>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"StoreArtifact", Schema.Struct<{
1334
+ readonly status: Schema.Literal<"conflict">;
1335
+ }>, Schema.Struct<{
1336
+ readonly status: Schema.Literal<"moved">;
1337
+ readonly head: Schema.String;
1338
+ }>]>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"AwaitEvent", Schema.Struct<{
1339
+ lease: Schema.Struct<{
1340
+ readonly workUnitId: Schema.String;
1341
+ readonly leaseOwnerId: Schema.String;
1342
+ readonly runnerReplicaId: Schema.String;
1343
+ readonly leaseId: Schema.String;
1344
+ readonly attempt: Schema.Int;
1345
+ readonly fencingToken: Schema.String;
1346
+ readonly capacitySlot: Schema.String;
1347
+ }>;
1348
+ step: Schema.String;
1349
+ deferredName: Schema.String;
1350
+ event: Schema.String;
1351
+ /** Event payload paths and the value, or any of the values, each must hold. */
1352
+ filter: Schema.optional<Schema.$Record<Schema.String, Schema.Union<readonly [Schema.Union<readonly [Schema.String, Schema.Finite, Schema.Boolean, Schema.Null]>, Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Finite, Schema.Boolean, Schema.Null]>>]>>>;
1353
+ timeoutMillis: Schema.Int;
1354
+ /** An ISO time: a state Event received before it never settles the wait, as a newer read superseded it. */
1355
+ since: Schema.optionalKey<Schema.String>;
1356
+ /** Other Events that settle the wait too, each with its own filter and `since`. */
1357
+ or: Schema.optionalKey<Schema.$Array<Schema.Struct<{
1358
+ readonly event: Schema.String;
1359
+ readonly filter: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Union<readonly [Schema.Union<readonly [Schema.String, Schema.Finite, Schema.Boolean, Schema.Null]>, Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Finite, Schema.Boolean, Schema.Null]>>]>>>;
1360
+ readonly since: Schema.optionalKey<Schema.String>;
1361
+ }>>>;
1362
+ }>, Schema.Void, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"ClaimResource", Schema.Struct<{
1363
+ lease: Schema.Struct<{
1364
+ readonly workUnitId: Schema.String;
1365
+ readonly leaseOwnerId: Schema.String;
1366
+ readonly runnerReplicaId: Schema.String;
1367
+ readonly leaseId: Schema.String;
1368
+ readonly attempt: Schema.Int;
1369
+ readonly fencingToken: Schema.String;
1370
+ readonly capacitySlot: Schema.String;
1371
+ }>;
1372
+ step: Schema.String;
1373
+ deferredName: Schema.String;
1374
+ resource: Schema.String;
1375
+ action: Schema.Literals<readonly ["claim", "take_over", "let_go"]>;
1376
+ }>, Schema.Void, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"RecordNote", Schema.Struct<{
1374
1377
  lease: Schema.Struct<{
1375
1378
  readonly workUnitId: Schema.String;
1376
1379
  readonly leaseOwnerId: Schema.String;
@@ -1381,14 +1384,11 @@ declare const RunnerCapabilityRpcs_base: RpcGroup.RpcGroup<Rpc.Rpc<"AdmitChild",
1381
1384
  readonly capacitySlot: Schema.String;
1382
1385
  }>;
1383
1386
  step: Schema.String;
1384
- kind: Schema.String;
1385
- title: Schema.String;
1386
1387
  text: Schema.String;
1387
- data: Schema.optional<Schema.Codec<Schema.Json, Schema.Json, never, never>>;
1388
- fileIds: Schema.optional<Schema.$Array<Schema.String>>;
1389
- }>, Schema.Struct<{
1390
- readonly artifactId: Schema.String;
1391
- }>, typeof RunnerRpcError, typeof RunnerAuthentication, never>>;
1388
+ artifactId: Schema.optional<Schema.String>;
1389
+ /** A `blocker` records what the Task waits on; a note when left out. */
1390
+ kind: Schema.optional<Schema.Literals<readonly ["note", "blocker"]>>;
1391
+ }>, Schema.Void, typeof RunnerRpcError, typeof RunnerAuthentication, never>>;
1392
1392
  /** A program's domain calls. */
1393
1393
  export declare class RunnerCapabilityRpcs extends RunnerCapabilityRpcs_base {
1394
1394
  }
@@ -1486,7 +1486,7 @@ declare const RunnerRunFileRpcs_base: RpcGroup.RpcGroup<Rpc.Rpc<"CompleteRunFile
1486
1486
  export declare class RunnerRunFileRpcs extends RunnerRunFileRpcs_base {
1487
1487
  }
1488
1488
  /** What a program process may call; its bundle speaks the Runner RPC protocol version through these. */
1489
- export declare const ProgramRpcs: RpcGroup.RpcGroup<Rpc.Rpc<"AdmitChild", Schema.Struct<{
1489
+ export declare const ProgramRpcs: RpcGroup.RpcGroup<Rpc.Rpc<"CreatePlanTasks", Schema.Struct<{
1490
1490
  lease: Schema.Struct<{
1491
1491
  readonly workUnitId: Schema.String;
1492
1492
  readonly leaseOwnerId: Schema.String;
@@ -1496,15 +1496,19 @@ export declare const ProgramRpcs: RpcGroup.RpcGroup<Rpc.Rpc<"AdmitChild", Schema
1496
1496
  readonly fencingToken: Schema.String;
1497
1497
  readonly capacitySlot: Schema.String;
1498
1498
  }>;
1499
- step: Schema.String;
1500
- loop: Schema.String;
1501
- input: Schema.Codec<Schema.Json, Schema.Json, never, never>;
1502
- /** Constraints the Child Run's Intent starts with besides its parent's. */
1503
- constraints: Schema.optional<Schema.$Array<Schema.String>>;
1504
- deferredName: Schema.String;
1505
- }>, Schema.Struct<{
1506
- readonly runId: Schema.String;
1507
- }>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"AlertTask", Schema.Struct<{
1499
+ projectId: Schema.optionalKey<Schema.String>;
1500
+ tickets: Schema.$Array<Schema.Struct<{
1501
+ readonly key: Schema.String;
1502
+ readonly title: Schema.String;
1503
+ readonly body: Schema.String;
1504
+ readonly acceptanceCriteria: Schema.$Array<Schema.String>;
1505
+ readonly blockedBy: Schema.$Array<Schema.String>;
1506
+ readonly outcome: Schema.optionalKey<Schema.Literals<readonly ["feature", "bug", "refactor", "investigation", "docs", "migration", "performance"]>>;
1507
+ }>>;
1508
+ }>, Schema.$Array<Schema.Struct<{
1509
+ readonly key: Schema.String;
1510
+ readonly taskId: Schema.String;
1511
+ }>>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"ProgramSecrets", Schema.Struct<{
1508
1512
  lease: Schema.Struct<{
1509
1513
  readonly workUnitId: Schema.String;
1510
1514
  readonly leaseOwnerId: Schema.String;
@@ -1514,21 +1518,7 @@ export declare const ProgramRpcs: RpcGroup.RpcGroup<Rpc.Rpc<"AdmitChild", Schema
1514
1518
  readonly fencingToken: Schema.String;
1515
1519
  readonly capacitySlot: Schema.String;
1516
1520
  }>;
1517
- step: Schema.String;
1518
- fingerprint: Schema.String;
1519
- title: Schema.String;
1520
- windowHours: Schema.Int;
1521
- resolved: Schema.optionalKey<Schema.Boolean>;
1522
- priority: Schema.optionalKey<Schema.Literals<readonly ["urgent", "high", "medium", "low"]>>;
1523
- }>, Schema.Struct<{
1524
- readonly taskId: Schema.optionalKey<Schema.String>;
1525
- readonly created: Schema.Boolean;
1526
- readonly resolved: Schema.optionalKey<Schema.Boolean>;
1527
- readonly joined: Schema.optionalKey<Schema.Struct<{
1528
- readonly kind: Schema.Literals<readonly ["run", "recent"]>;
1529
- readonly runId: Schema.String;
1530
- }>>;
1531
- }>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"ApproveChangeRequest", Schema.Struct<{
1521
+ }>, Schema.$Record<Schema.String, Schema.String>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"CompleteRunFile", Schema.Struct<{
1532
1522
  lease: Schema.Struct<{
1533
1523
  readonly workUnitId: Schema.String;
1534
1524
  readonly leaseOwnerId: Schema.String;
@@ -1538,19 +1528,23 @@ export declare const ProgramRpcs: RpcGroup.RpcGroup<Rpc.Rpc<"AdmitChild", Schema
1538
1528
  readonly fencingToken: Schema.String;
1539
1529
  readonly capacitySlot: Schema.String;
1540
1530
  }>;
1541
- step: Schema.String;
1542
- changeRequestId: Schema.String;
1543
- head: Schema.String;
1544
- summary: Schema.String;
1545
- review: Schema.optionalKey<Schema.String>;
1546
- carries: Schema.optionalKey<Schema.String>;
1547
- }>, Schema.Union<readonly [Schema.Struct<{
1548
- readonly approved: Schema.Literal<true>;
1549
- readonly reviewId: Schema.String;
1531
+ fileId: Schema.String;
1532
+ parts: Schema.optional<Schema.$Array<Schema.Struct<{
1533
+ readonly partNumber: Schema.Int;
1534
+ readonly etag: Schema.String;
1535
+ }>>>;
1550
1536
  }>, Schema.Struct<{
1551
- readonly approved: Schema.Literal<false>;
1552
- readonly reason: Schema.String;
1553
- }>]>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"AwaitEvent", Schema.Struct<{
1537
+ readonly id: Schema.String;
1538
+ readonly runId: Schema.String;
1539
+ readonly step: Schema.String;
1540
+ readonly name: Schema.String;
1541
+ readonly caption: Schema.optionalKey<Schema.String>;
1542
+ readonly contentType: Schema.String;
1543
+ readonly kind: Schema.Literals<readonly ["image", "video", "html", "text", "other"]>;
1544
+ readonly byteSize: Schema.Int;
1545
+ readonly sha256: Schema.String;
1546
+ readonly status: Schema.Literals<readonly ["uploading", "available", "rejected", "refused", "removing", "removed", "expired"]>;
1547
+ }>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"PutQuestion", Schema.Struct<{
1554
1548
  lease: Schema.Struct<{
1555
1549
  readonly workUnitId: Schema.String;
1556
1550
  readonly leaseOwnerId: Schema.String;
@@ -1561,20 +1555,29 @@ export declare const ProgramRpcs: RpcGroup.RpcGroup<Rpc.Rpc<"AdmitChild", Schema
1561
1555
  readonly capacitySlot: Schema.String;
1562
1556
  }>;
1563
1557
  step: Schema.String;
1558
+ prompt: Schema.String;
1559
+ options: Schema.optional<Schema.$Array<Schema.String>>;
1560
+ optionDescriptions: Schema.optional<Schema.$Record<Schema.String, Schema.String>>;
1561
+ recommended: Schema.optional<Schema.String>;
1562
+ recommendationReason: Schema.optional<Schema.String>;
1563
+ informationOnly: Schema.optional<Schema.Boolean>;
1564
+ /** Approving the Question approves this verification for the Run's repository. */
1565
+ verification: Schema.optional<Schema.Struct<{
1566
+ readonly name: Schema.String;
1567
+ readonly command: Schema.String;
1568
+ readonly workingDirectory: Schema.optional<Schema.String>;
1569
+ }>>;
1570
+ /** Taken when the Run is unattended, or when nobody answers within `timeoutMillis`. */
1571
+ default: Schema.optional<Schema.String>;
1572
+ /** Taken at once when the Run's Team delivers in full auto. */
1573
+ auto: Schema.optional<Schema.String>;
1574
+ /** Taken at once when the Run's Team delivers in full auto and nobody attends the Run. */
1575
+ unattendedAuto: Schema.optional<Schema.String>;
1576
+ timeoutMillis: Schema.optional<Schema.Finite>;
1564
1577
  deferredName: Schema.String;
1565
- event: Schema.String;
1566
- /** Event payload paths and the value, or any of the values, each must hold. */
1567
- filter: Schema.optional<Schema.$Record<Schema.String, Schema.Union<readonly [Schema.Union<readonly [Schema.String, Schema.Finite, Schema.Boolean, Schema.Null]>, Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Finite, Schema.Boolean, Schema.Null]>>]>>>;
1568
- timeoutMillis: Schema.Int;
1569
- /** An ISO time: a state Event received before it never settles the wait, as a newer read superseded it. */
1570
- since: Schema.optionalKey<Schema.String>;
1571
- /** Other Events that settle the wait too, each with its own filter and `since`. */
1572
- or: Schema.optionalKey<Schema.$Array<Schema.Struct<{
1573
- readonly event: Schema.String;
1574
- readonly filter: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Union<readonly [Schema.Union<readonly [Schema.String, Schema.Finite, Schema.Boolean, Schema.Null]>, Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Finite, Schema.Boolean, Schema.Null]>>]>>>;
1575
- readonly since: Schema.optionalKey<Schema.String>;
1576
- }>>>;
1577
- }>, Schema.Void, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"ClaimResource", Schema.Struct<{
1578
+ }>, Schema.Struct<{
1579
+ readonly questionId: Schema.String;
1580
+ }>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"StartAgentStep", Schema.Struct<{
1578
1581
  lease: Schema.Struct<{
1579
1582
  readonly workUnitId: Schema.String;
1580
1583
  readonly leaseOwnerId: Schema.String;
@@ -1586,9 +1589,19 @@ export declare const ProgramRpcs: RpcGroup.RpcGroup<Rpc.Rpc<"AdmitChild", Schema
1586
1589
  }>;
1587
1590
  step: Schema.String;
1588
1591
  deferredName: Schema.String;
1589
- resource: Schema.String;
1590
- action: Schema.Literals<readonly ["claim", "take_over", "let_go"]>;
1591
- }>, Schema.Void, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"CloseChangeRequest", Schema.Struct<{
1592
+ role: Schema.String;
1593
+ agentId: Schema.String;
1594
+ prompt: Schema.String;
1595
+ /** The skill the Step runs. */
1596
+ skill: Schema.optionalKey<Schema.String>;
1597
+ outputSchema: Schema.Codec<Schema.Json, Schema.Json, never, never>;
1598
+ secrets: Schema.optionalKey<Schema.$Array<Schema.String>>;
1599
+ timeoutMillis: Schema.optionalKey<Schema.Int>;
1600
+ /** The branch whose head the Runner merges into the checkout before the agent starts. */
1601
+ mergeTarget: Schema.optionalKey<Schema.String>;
1602
+ }>, Schema.Struct<{
1603
+ readonly stepAttemptId: Schema.String;
1604
+ }>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"StartVerification", Schema.Struct<{
1592
1605
  lease: Schema.Struct<{
1593
1606
  readonly workUnitId: Schema.String;
1594
1607
  readonly leaseOwnerId: Schema.String;
@@ -1599,13 +1612,44 @@ export declare const ProgramRpcs: RpcGroup.RpcGroup<Rpc.Rpc<"AdmitChild", Schema
1599
1612
  readonly capacitySlot: Schema.String;
1600
1613
  }>;
1601
1614
  step: Schema.String;
1602
- number: Schema.String;
1603
- head: Schema.String;
1604
- note: Schema.String;
1615
+ deferredName: Schema.String;
1616
+ /** The Run's head when left out. */
1617
+ revision: Schema.optionalKey<Schema.String>;
1618
+ checks: Schema.optional<Schema.$Array<Schema.String>>;
1619
+ /** Run, labelled as suggested, when the repository has no approved checks. */
1620
+ suggested: Schema.optionalKey<Schema.$Array<Schema.Struct<{
1621
+ readonly name: Schema.String;
1622
+ readonly command: Schema.String;
1623
+ readonly workingDirectory: Schema.optionalKey<Schema.String>;
1624
+ readonly suggested: Schema.optionalKey<Schema.Boolean>;
1625
+ }>>>;
1626
+ /** Runs a check again whose evidence at the tree failed, rather than reusing that failure; passed evidence is still reused. */
1627
+ rerunFailed: Schema.optionalKey<Schema.Boolean>;
1628
+ /** A benchmark against `base` (the Run's base branch head when left out) in place of checks. */
1629
+ measure: Schema.optionalKey<Schema.Struct<{
1630
+ readonly base: Schema.optionalKey<Schema.String>;
1631
+ readonly plan: Schema.Struct<{
1632
+ readonly command: Schema.String;
1633
+ readonly prepare: Schema.optionalKey<Schema.String>;
1634
+ readonly workingDirectory: Schema.optionalKey<Schema.String>;
1635
+ readonly warmup: Schema.optionalKey<Schema.Int>;
1636
+ readonly metrics: Schema.$Array<Schema.Struct<{
1637
+ readonly name: Schema.String;
1638
+ readonly direction: Schema.Literals<readonly ["lower", "higher"]>;
1639
+ readonly role: Schema.Literals<readonly ["primary", "guardrail"]>;
1640
+ readonly lowVariance: Schema.optionalKey<Schema.Boolean>;
1641
+ }>>;
1642
+ }>;
1643
+ readonly samples: Schema.Int;
1644
+ readonly calibrate: Schema.Boolean;
1645
+ }>>;
1646
+ /** Revisions to resolve to commits in place of checks. */
1647
+ resolve: Schema.optionalKey<Schema.Struct<{
1648
+ readonly revisions: Schema.$Array<Schema.String>;
1649
+ }>>;
1605
1650
  }>, Schema.Struct<{
1606
- readonly closed: Schema.Boolean;
1607
- readonly head: Schema.optionalKey<Schema.String>;
1608
- }>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"CompleteRunFile", Schema.Struct<{
1651
+ readonly verificationId: Schema.String;
1652
+ }>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"AdmitChild", Schema.Struct<{
1609
1653
  lease: Schema.Struct<{
1610
1654
  readonly workUnitId: Schema.String;
1611
1655
  readonly leaseOwnerId: Schema.String;
@@ -1615,23 +1659,15 @@ export declare const ProgramRpcs: RpcGroup.RpcGroup<Rpc.Rpc<"AdmitChild", Schema
1615
1659
  readonly fencingToken: Schema.String;
1616
1660
  readonly capacitySlot: Schema.String;
1617
1661
  }>;
1618
- fileId: Schema.String;
1619
- parts: Schema.optional<Schema.$Array<Schema.Struct<{
1620
- readonly partNumber: Schema.Int;
1621
- readonly etag: Schema.String;
1622
- }>>>;
1662
+ step: Schema.String;
1663
+ loop: Schema.String;
1664
+ input: Schema.Codec<Schema.Json, Schema.Json, never, never>;
1665
+ /** Constraints the Child Run's Intent starts with besides its parent's. */
1666
+ constraints: Schema.optional<Schema.$Array<Schema.String>>;
1667
+ deferredName: Schema.String;
1623
1668
  }>, Schema.Struct<{
1624
- readonly id: Schema.String;
1625
1669
  readonly runId: Schema.String;
1626
- readonly step: Schema.String;
1627
- readonly name: Schema.String;
1628
- readonly caption: Schema.optionalKey<Schema.String>;
1629
- readonly contentType: Schema.String;
1630
- readonly kind: Schema.Literals<readonly ["image", "video", "html", "text", "other"]>;
1631
- readonly byteSize: Schema.Int;
1632
- readonly sha256: Schema.String;
1633
- readonly status: Schema.Literals<readonly ["uploading", "available", "rejected", "refused", "removing", "removed", "expired"]>;
1634
- }>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"CreatePlanTasks", Schema.Struct<{
1670
+ }>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"StoreArtifact", Schema.Struct<{
1635
1671
  lease: Schema.Struct<{
1636
1672
  readonly workUnitId: Schema.String;
1637
1673
  readonly leaseOwnerId: Schema.String;
@@ -1641,19 +1677,15 @@ export declare const ProgramRpcs: RpcGroup.RpcGroup<Rpc.Rpc<"AdmitChild", Schema
1641
1677
  readonly fencingToken: Schema.String;
1642
1678
  readonly capacitySlot: Schema.String;
1643
1679
  }>;
1644
- projectId: Schema.optionalKey<Schema.String>;
1645
- tickets: Schema.$Array<Schema.Struct<{
1646
- readonly key: Schema.String;
1647
- readonly title: Schema.String;
1648
- readonly body: Schema.String;
1649
- readonly acceptanceCriteria: Schema.$Array<Schema.String>;
1650
- readonly blockedBy: Schema.$Array<Schema.String>;
1651
- readonly outcome: Schema.optionalKey<Schema.Literals<readonly ["feature", "bug", "refactor", "investigation", "docs", "migration", "performance"]>>;
1652
- }>>;
1653
- }>, Schema.$Array<Schema.Struct<{
1654
- readonly key: Schema.String;
1655
- readonly taskId: Schema.String;
1656
- }>>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"CreateRunFile", Schema.Struct<{
1680
+ step: Schema.String;
1681
+ kind: Schema.String;
1682
+ title: Schema.String;
1683
+ text: Schema.String;
1684
+ data: Schema.optional<Schema.Codec<Schema.Json, Schema.Json, never, never>>;
1685
+ fileIds: Schema.optional<Schema.$Array<Schema.String>>;
1686
+ }>, Schema.Struct<{
1687
+ readonly artifactId: Schema.String;
1688
+ }>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"AlertTask", Schema.Struct<{
1657
1689
  lease: Schema.Struct<{
1658
1690
  readonly workUnitId: Schema.String;
1659
1691
  readonly leaseOwnerId: Schema.String;
@@ -1664,52 +1696,20 @@ export declare const ProgramRpcs: RpcGroup.RpcGroup<Rpc.Rpc<"AdmitChild", Schema
1664
1696
  readonly capacitySlot: Schema.String;
1665
1697
  }>;
1666
1698
  step: Schema.String;
1667
- name: Schema.String;
1668
- caption: Schema.optional<Schema.String>;
1669
- contentType: Schema.String;
1670
- byteSize: Schema.Int;
1671
- sha256: Schema.String;
1699
+ fingerprint: Schema.String;
1700
+ title: Schema.String;
1701
+ windowHours: Schema.Int;
1702
+ resolved: Schema.optionalKey<Schema.Boolean>;
1703
+ priority: Schema.optionalKey<Schema.Literals<readonly ["urgent", "high", "medium", "low"]>>;
1672
1704
  }>, Schema.Struct<{
1673
- readonly file: Schema.Struct<{
1674
- readonly id: Schema.String;
1705
+ readonly taskId: Schema.optionalKey<Schema.String>;
1706
+ readonly created: Schema.Boolean;
1707
+ readonly resolved: Schema.optionalKey<Schema.Boolean>;
1708
+ readonly joined: Schema.optionalKey<Schema.Struct<{
1709
+ readonly kind: Schema.Literals<readonly ["run", "recent"]>;
1675
1710
  readonly runId: Schema.String;
1676
- readonly step: Schema.String;
1677
- readonly name: Schema.String;
1678
- readonly caption: Schema.optionalKey<Schema.String>;
1679
- readonly contentType: Schema.String;
1680
- readonly kind: Schema.Literals<readonly ["image", "video", "html", "text", "other"]>;
1681
- readonly byteSize: Schema.Int;
1682
- readonly sha256: Schema.String;
1683
- readonly status: Schema.Literals<readonly ["uploading", "available", "rejected", "refused", "removing", "removed", "expired"]>;
1684
- }>;
1685
- readonly upload: Schema.optional<Schema.Union<readonly [Schema.Struct<{
1686
- readonly url: Schema.String;
1687
- readonly headers: Schema.optionalKey<Schema.$Record<Schema.String, Schema.String>>;
1688
- readonly expiresAt: Schema.String;
1689
- readonly kind: Schema.Literal<"single">;
1690
- }>, Schema.Struct<{
1691
- readonly kind: Schema.Literal<"multipart">;
1692
- readonly partSize: Schema.Int;
1693
- readonly parts: Schema.$Array<Schema.Struct<{
1694
- readonly url: Schema.String;
1695
- readonly headers: Schema.optionalKey<Schema.$Record<Schema.String, Schema.String>>;
1696
- readonly expiresAt: Schema.String;
1697
- readonly partNumber: Schema.Int;
1698
- }>>;
1699
- }>]>>;
1700
- }>, Schema.Union<readonly [typeof RunnerRpcError, typeof RunFileRefused]>, typeof RunnerAuthentication, never> | Rpc.Rpc<"DeferredDone", Schema.Struct<{
1701
- lease: Schema.Struct<{
1702
- readonly workUnitId: Schema.String;
1703
- readonly leaseOwnerId: Schema.String;
1704
- readonly runnerReplicaId: Schema.String;
1705
- readonly leaseId: Schema.String;
1706
- readonly attempt: Schema.Int;
1707
- readonly fencingToken: Schema.String;
1708
- readonly capacitySlot: Schema.String;
1709
- }>;
1710
- name: Schema.String;
1711
- exit: Schema.Codec<Schema.Json, Schema.Json, never, never>;
1712
- }>, Schema.Void, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"DraftUpdate", Schema.Struct<{
1711
+ }>>;
1712
+ }>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"ReadTranscripts", Schema.Struct<{
1713
1713
  lease: Schema.Struct<{
1714
1714
  readonly workUnitId: Schema.String;
1715
1715
  readonly leaseOwnerId: Schema.String;
@@ -1720,17 +1720,23 @@ export declare const ProgramRpcs: RpcGroup.RpcGroup<Rpc.Rpc<"AdmitChild", Schema
1720
1720
  readonly capacitySlot: Schema.String;
1721
1721
  }>;
1722
1722
  step: Schema.String;
1723
- projectId: Schema.String;
1724
- health: Schema.Literals<readonly ["on_track", "at_risk", "off_track"]>;
1725
- note: Schema.String;
1726
- writtenFrom: Schema.Struct<{
1727
- readonly runs: Schema.Int;
1728
- readonly taskChanges: Schema.Int;
1729
- readonly since: Schema.optionalKey<Schema.String>;
1730
- }>;
1723
+ days: Schema.Int;
1731
1724
  }>, Schema.Struct<{
1732
- readonly id: Schema.String;
1733
- }>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"FinishProgram", Schema.Struct<{
1725
+ readonly runs: Schema.$Array<Schema.Struct<{
1726
+ readonly runId: Schema.String;
1727
+ readonly loopId: Schema.String;
1728
+ readonly status: Schema.optionalKey<Schema.Literals<readonly ["completed", "failed", "canceled", "expired"]>>;
1729
+ readonly teamId: Schema.optionalKey<Schema.String>;
1730
+ readonly failure: Schema.optionalKey<Schema.String>;
1731
+ readonly retried: Schema.optionalKey<Schema.Boolean>;
1732
+ readonly entries: Schema.$Array<Schema.Struct<{
1733
+ readonly stepAttemptId: Schema.String;
1734
+ readonly sequence: Schema.Int;
1735
+ readonly kind: Schema.String;
1736
+ readonly text: Schema.String;
1737
+ }>>;
1738
+ }>>;
1739
+ }>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"PipelineStatus", Schema.Struct<{
1734
1740
  lease: Schema.Struct<{
1735
1741
  readonly workUnitId: Schema.String;
1736
1742
  readonly leaseOwnerId: Schema.String;
@@ -1740,14 +1746,36 @@ export declare const ProgramRpcs: RpcGroup.RpcGroup<Rpc.Rpc<"AdmitChild", Schema
1740
1746
  readonly fencingToken: Schema.String;
1741
1747
  readonly capacitySlot: Schema.String;
1742
1748
  }>;
1743
- outcome: Schema.Union<readonly [Schema.Struct<{
1744
- readonly status: Schema.Literal<"completed">;
1745
- readonly output: Schema.Codec<Schema.Json, Schema.Json, never, never>;
1746
- }>, Schema.Struct<{
1747
- readonly status: Schema.Literal<"failed">;
1748
- readonly failureSummary: Schema.String;
1749
- }>]>;
1750
- }>, Schema.Void, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"IntegrationBranch", Schema.Struct<{
1749
+ step: Schema.String;
1750
+ changeRequestId: Schema.String;
1751
+ }>, Schema.Struct<{
1752
+ readonly head: Schema.String;
1753
+ readonly status: Schema.Literals<readonly ["none", "running", "success", "failed", "canceled"]>;
1754
+ readonly source: Schema.Literals<readonly ["forge", "reported"]>;
1755
+ readonly jobs: Schema.$Array<Schema.Struct<{
1756
+ readonly name: Schema.String;
1757
+ readonly status: Schema.Literals<readonly ["running", "success", "failed", "skipped"]>;
1758
+ readonly url: Schema.optionalKey<Schema.String>;
1759
+ readonly logTail: Schema.optionalKey<Schema.String>;
1760
+ }>>;
1761
+ readonly readAt: Schema.optionalKey<Schema.String>;
1762
+ readonly runnerChecks: Schema.optionalKey<Schema.$Array<Schema.String>>;
1763
+ readonly approved: Schema.optionalKey<Schema.String>;
1764
+ readonly repository: Schema.optionalKey<Schema.String>;
1765
+ readonly targetBranch: Schema.optionalKey<Schema.String>;
1766
+ readonly conflicts: Schema.optionalKey<Schema.Boolean>;
1767
+ readonly needsRebase: Schema.optionalKey<Schema.Boolean>;
1768
+ readonly target: Schema.optionalKey<Schema.Struct<{
1769
+ readonly branch: Schema.String;
1770
+ readonly head: Schema.String;
1771
+ readonly jobs: Schema.$Array<Schema.Struct<{
1772
+ readonly name: Schema.String;
1773
+ readonly status: Schema.Literals<readonly ["running", "success", "failed", "skipped"]>;
1774
+ readonly url: Schema.optionalKey<Schema.String>;
1775
+ readonly logTail: Schema.optionalKey<Schema.String>;
1776
+ }>>;
1777
+ }>>;
1778
+ }>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"ReportPipeline", Schema.Struct<{
1751
1779
  lease: Schema.Struct<{
1752
1780
  readonly workUnitId: Schema.String;
1753
1781
  readonly leaseOwnerId: Schema.String;
@@ -1757,12 +1785,13 @@ export declare const ProgramRpcs: RpcGroup.RpcGroup<Rpc.Rpc<"AdmitChild", Schema
1757
1785
  readonly fencingToken: Schema.String;
1758
1786
  readonly capacitySlot: Schema.String;
1759
1787
  }>;
1760
- repoBindingId: Schema.optionalKey<Schema.String>;
1788
+ step: Schema.String;
1789
+ changeRequestId: Schema.String;
1790
+ verification: Schema.String;
1761
1791
  }>, Schema.Struct<{
1762
- readonly repoBindingId: Schema.String;
1763
- readonly branch: Schema.String;
1764
- readonly revision: Schema.String;
1765
- }>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"MergeChangeRequest", Schema.Struct<{
1792
+ readonly head: Schema.String;
1793
+ readonly status: Schema.Literals<readonly ["success", "failed"]>;
1794
+ }>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"ReviewThreads", Schema.Struct<{
1766
1795
  lease: Schema.Struct<{
1767
1796
  readonly workUnitId: Schema.String;
1768
1797
  readonly leaseOwnerId: Schema.String;
@@ -1774,16 +1803,18 @@ export declare const ProgramRpcs: RpcGroup.RpcGroup<Rpc.Rpc<"AdmitChild", Schema
1774
1803
  }>;
1775
1804
  step: Schema.String;
1776
1805
  changeRequestId: Schema.String;
1777
- head: Schema.optionalKey<Schema.String>;
1778
- }>, Schema.Union<readonly [Schema.Struct<{
1779
- readonly status: Schema.Literal<"merged">;
1780
- readonly revision: Schema.String;
1781
- }>, Schema.Struct<{
1782
- readonly status: Schema.Literal<"conflict">;
1783
1806
  }>, Schema.Struct<{
1784
- readonly status: Schema.Literal<"moved">;
1785
- readonly head: Schema.String;
1786
- }>]>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"OpenChangeRequests", Schema.Struct<{
1807
+ readonly threads: Schema.$Array<Schema.Struct<{
1808
+ readonly id: Schema.String;
1809
+ readonly path: Schema.optionalKey<Schema.String>;
1810
+ readonly line: Schema.optionalKey<Schema.Int>;
1811
+ readonly outdated: Schema.optionalKey<Schema.Boolean>;
1812
+ readonly comments: Schema.$Array<Schema.Struct<{
1813
+ readonly author: Schema.optionalKey<Schema.String>;
1814
+ readonly body: Schema.String;
1815
+ }>>;
1816
+ }>>;
1817
+ }>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"OpenChangeRequests", Schema.Struct<{
1787
1818
  lease: Schema.Struct<{
1788
1819
  readonly workUnitId: Schema.String;
1789
1820
  readonly leaseOwnerId: Schema.String;
@@ -1825,92 +1856,7 @@ export declare const ProgramRpcs: RpcGroup.RpcGroup<Rpc.Rpc<"AdmitChild", Schema
1825
1856
  readonly sourceBranch: Schema.String;
1826
1857
  readonly body: Schema.String;
1827
1858
  }>>;
1828
- }>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"PerformHostEffect", Schema.Struct<{
1829
- lease: Schema.Struct<{
1830
- readonly workUnitId: Schema.String;
1831
- readonly leaseOwnerId: Schema.String;
1832
- readonly runnerReplicaId: Schema.String;
1833
- readonly leaseId: Schema.String;
1834
- readonly attempt: Schema.Int;
1835
- readonly fencingToken: Schema.String;
1836
- readonly capacitySlot: Schema.String;
1837
- }>;
1838
- step: Schema.String;
1839
- effect: Schema.Union<readonly [Schema.Struct<{
1840
- readonly kind: Schema.Literal<"post_comment">;
1841
- readonly changeRequestId: Schema.String;
1842
- readonly body: Schema.String;
1843
- readonly threadId: Schema.optionalKey<Schema.String>;
1844
- readonly summary: Schema.optionalKey<Schema.String>;
1845
- readonly anchors: Schema.optionalKey<Schema.$Array<Schema.Struct<{
1846
- readonly file: Schema.String;
1847
- readonly line: Schema.Int;
1848
- readonly body: Schema.String;
1849
- }>>>;
1850
- }>, Schema.Struct<{
1851
- readonly kind: Schema.Literal<"change_request">;
1852
- readonly title: Schema.String;
1853
- readonly body: Schema.String;
1854
- readonly integration: Schema.optionalKey<Schema.String>;
1855
- }>, Schema.Struct<{
1856
- readonly kind: Schema.Literal<"write_back">;
1857
- readonly milestone: Schema.optionalKey<Schema.Literals<readonly ["started", "change_request_opened", "merged", "failed"]>>;
1858
- readonly changeRequestUrl: Schema.optionalKey<Schema.String>;
1859
- }>]>;
1860
- }>, Schema.UndefinedOr<Schema.Struct<{
1861
- readonly id: Schema.String;
1862
- readonly number: Schema.String;
1863
- readonly url: Schema.String;
1864
- }>>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"PipelineStatus", Schema.Struct<{
1865
- lease: Schema.Struct<{
1866
- readonly workUnitId: Schema.String;
1867
- readonly leaseOwnerId: Schema.String;
1868
- readonly runnerReplicaId: Schema.String;
1869
- readonly leaseId: Schema.String;
1870
- readonly attempt: Schema.Int;
1871
- readonly fencingToken: Schema.String;
1872
- readonly capacitySlot: Schema.String;
1873
- }>;
1874
- step: Schema.String;
1875
- changeRequestId: Schema.String;
1876
- }>, Schema.Struct<{
1877
- readonly head: Schema.String;
1878
- readonly status: Schema.Literals<readonly ["none", "running", "success", "failed", "canceled"]>;
1879
- readonly source: Schema.Literals<readonly ["forge", "reported"]>;
1880
- readonly jobs: Schema.$Array<Schema.Struct<{
1881
- readonly name: Schema.String;
1882
- readonly status: Schema.Literals<readonly ["running", "success", "failed", "skipped"]>;
1883
- readonly url: Schema.optionalKey<Schema.String>;
1884
- readonly logTail: Schema.optionalKey<Schema.String>;
1885
- }>>;
1886
- readonly readAt: Schema.optionalKey<Schema.String>;
1887
- readonly runnerChecks: Schema.optionalKey<Schema.$Array<Schema.String>>;
1888
- readonly approved: Schema.optionalKey<Schema.String>;
1889
- readonly repository: Schema.optionalKey<Schema.String>;
1890
- readonly targetBranch: Schema.optionalKey<Schema.String>;
1891
- readonly conflicts: Schema.optionalKey<Schema.Boolean>;
1892
- readonly needsRebase: Schema.optionalKey<Schema.Boolean>;
1893
- readonly target: Schema.optionalKey<Schema.Struct<{
1894
- readonly branch: Schema.String;
1895
- readonly head: Schema.String;
1896
- readonly jobs: Schema.$Array<Schema.Struct<{
1897
- readonly name: Schema.String;
1898
- readonly status: Schema.Literals<readonly ["running", "success", "failed", "skipped"]>;
1899
- readonly url: Schema.optionalKey<Schema.String>;
1900
- readonly logTail: Schema.optionalKey<Schema.String>;
1901
- }>>;
1902
- }>>;
1903
- }>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"ProgramSecrets", Schema.Struct<{
1904
- lease: Schema.Struct<{
1905
- readonly workUnitId: Schema.String;
1906
- readonly leaseOwnerId: Schema.String;
1907
- readonly runnerReplicaId: Schema.String;
1908
- readonly leaseId: Schema.String;
1909
- readonly attempt: Schema.Int;
1910
- readonly fencingToken: Schema.String;
1911
- readonly capacitySlot: Schema.String;
1912
- }>;
1913
- }>, Schema.$Record<Schema.String, Schema.String>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"Propose", Schema.Struct<{
1859
+ }>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"Propose", Schema.Struct<{
1914
1860
  lease: Schema.Struct<{
1915
1861
  readonly workUnitId: Schema.String;
1916
1862
  readonly leaseOwnerId: Schema.String;
@@ -1946,7 +1892,7 @@ export declare const ProgramRpcs: RpcGroup.RpcGroup<Rpc.Rpc<"AdmitChild", Schema
1946
1892
  readonly kind: Schema.Literals<readonly ["memory", "task"]>;
1947
1893
  readonly id: Schema.String;
1948
1894
  readonly matched: Schema.optionalKey<Schema.Boolean>;
1949
- }>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"PublishRelease", Schema.Struct<{
1895
+ }>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"ReadProject", Schema.Struct<{
1950
1896
  lease: Schema.Struct<{
1951
1897
  readonly workUnitId: Schema.String;
1952
1898
  readonly leaseOwnerId: Schema.String;
@@ -1957,59 +1903,7 @@ export declare const ProgramRpcs: RpcGroup.RpcGroup<Rpc.Rpc<"AdmitChild", Schema
1957
1903
  readonly capacitySlot: Schema.String;
1958
1904
  }>;
1959
1905
  step: Schema.String;
1960
- tag: Schema.String;
1961
- revision: Schema.optionalKey<Schema.String>;
1962
- title: Schema.String;
1963
- notes: Schema.String;
1964
- }>, Schema.Struct<{
1965
- readonly tag: Schema.String;
1966
- readonly revision: Schema.String;
1967
- readonly url: Schema.String;
1968
- }>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"PutQuestion", Schema.Struct<{
1969
- lease: Schema.Struct<{
1970
- readonly workUnitId: Schema.String;
1971
- readonly leaseOwnerId: Schema.String;
1972
- readonly runnerReplicaId: Schema.String;
1973
- readonly leaseId: Schema.String;
1974
- readonly attempt: Schema.Int;
1975
- readonly fencingToken: Schema.String;
1976
- readonly capacitySlot: Schema.String;
1977
- }>;
1978
- step: Schema.String;
1979
- prompt: Schema.String;
1980
- options: Schema.optional<Schema.$Array<Schema.String>>;
1981
- optionDescriptions: Schema.optional<Schema.$Record<Schema.String, Schema.String>>;
1982
- recommended: Schema.optional<Schema.String>;
1983
- recommendationReason: Schema.optional<Schema.String>;
1984
- informationOnly: Schema.optional<Schema.Boolean>;
1985
- /** Approving the Question approves this verification for the Run's repository. */
1986
- verification: Schema.optional<Schema.Struct<{
1987
- readonly name: Schema.String;
1988
- readonly command: Schema.String;
1989
- readonly workingDirectory: Schema.optional<Schema.String>;
1990
- }>>;
1991
- /** Taken when the Run is unattended, or when nobody answers within `timeoutMillis`. */
1992
- default: Schema.optional<Schema.String>;
1993
- /** Taken at once when the Run's Team delivers in full auto. */
1994
- auto: Schema.optional<Schema.String>;
1995
- /** Taken at once when the Run's Team delivers in full auto and nobody attends the Run. */
1996
- unattendedAuto: Schema.optional<Schema.String>;
1997
- timeoutMillis: Schema.optional<Schema.Finite>;
1998
- deferredName: Schema.String;
1999
- }>, Schema.Struct<{
2000
- readonly questionId: Schema.String;
2001
- }>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"ReadProject", Schema.Struct<{
2002
- lease: Schema.Struct<{
2003
- readonly workUnitId: Schema.String;
2004
- readonly leaseOwnerId: Schema.String;
2005
- readonly runnerReplicaId: Schema.String;
2006
- readonly leaseId: Schema.String;
2007
- readonly attempt: Schema.Int;
2008
- readonly fencingToken: Schema.String;
2009
- readonly capacitySlot: Schema.String;
2010
- }>;
2011
- step: Schema.String;
2012
- projectId: Schema.String;
1906
+ projectId: Schema.String;
2013
1907
  }>, Schema.Struct<{
2014
1908
  readonly project: Schema.Struct<{
2015
1909
  readonly id: Schema.String;
@@ -2037,7 +1931,7 @@ export declare const ProgramRpcs: RpcGroup.RpcGroup<Rpc.Rpc<"AdmitChild", Schema
2037
1931
  readonly change: Schema.String;
2038
1932
  readonly at: Schema.String;
2039
1933
  }>>;
2040
- }>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"ReadTranscripts", Schema.Struct<{
1934
+ }>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"DraftUpdate", Schema.Struct<{
2041
1935
  lease: Schema.Struct<{
2042
1936
  readonly workUnitId: Schema.String;
2043
1937
  readonly leaseOwnerId: Schema.String;
@@ -2048,23 +1942,17 @@ export declare const ProgramRpcs: RpcGroup.RpcGroup<Rpc.Rpc<"AdmitChild", Schema
2048
1942
  readonly capacitySlot: Schema.String;
2049
1943
  }>;
2050
1944
  step: Schema.String;
2051
- days: Schema.Int;
1945
+ projectId: Schema.String;
1946
+ health: Schema.Literals<readonly ["on_track", "at_risk", "off_track"]>;
1947
+ note: Schema.String;
1948
+ writtenFrom: Schema.Struct<{
1949
+ readonly runs: Schema.Int;
1950
+ readonly taskChanges: Schema.Int;
1951
+ readonly since: Schema.optionalKey<Schema.String>;
1952
+ }>;
2052
1953
  }>, Schema.Struct<{
2053
- readonly runs: Schema.$Array<Schema.Struct<{
2054
- readonly runId: Schema.String;
2055
- readonly loopId: Schema.String;
2056
- readonly status: Schema.optionalKey<Schema.Literals<readonly ["completed", "failed", "canceled", "expired"]>>;
2057
- readonly teamId: Schema.optionalKey<Schema.String>;
2058
- readonly failure: Schema.optionalKey<Schema.String>;
2059
- readonly retried: Schema.optionalKey<Schema.Boolean>;
2060
- readonly entries: Schema.$Array<Schema.Struct<{
2061
- readonly stepAttemptId: Schema.String;
2062
- readonly sequence: Schema.Int;
2063
- readonly kind: Schema.String;
2064
- readonly text: Schema.String;
2065
- }>>;
2066
- }>>;
2067
- }>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"RecordActivity", Schema.Struct<{
1954
+ readonly id: Schema.String;
1955
+ }>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"IntegrationBranch", Schema.Struct<{
2068
1956
  lease: Schema.Struct<{
2069
1957
  readonly workUnitId: Schema.String;
2070
1958
  readonly leaseOwnerId: Schema.String;
@@ -2074,10 +1962,12 @@ export declare const ProgramRpcs: RpcGroup.RpcGroup<Rpc.Rpc<"AdmitChild", Schema
2074
1962
  readonly fencingToken: Schema.String;
2075
1963
  readonly capacitySlot: Schema.String;
2076
1964
  }>;
2077
- name: Schema.String;
2078
- attempt: Schema.Int;
2079
- exit: Schema.Codec<Schema.Json, Schema.Json, never, never>;
2080
- }>, Schema.Void, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"RecordNote", Schema.Struct<{
1965
+ repoBindingId: Schema.optionalKey<Schema.String>;
1966
+ }>, Schema.Struct<{
1967
+ readonly repoBindingId: Schema.String;
1968
+ readonly branch: Schema.String;
1969
+ readonly revision: Schema.String;
1970
+ }>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"CloseChangeRequest", Schema.Struct<{
2081
1971
  lease: Schema.Struct<{
2082
1972
  readonly workUnitId: Schema.String;
2083
1973
  readonly leaseOwnerId: Schema.String;
@@ -2088,11 +1978,13 @@ export declare const ProgramRpcs: RpcGroup.RpcGroup<Rpc.Rpc<"AdmitChild", Schema
2088
1978
  readonly capacitySlot: Schema.String;
2089
1979
  }>;
2090
1980
  step: Schema.String;
2091
- text: Schema.String;
2092
- artifactId: Schema.optional<Schema.String>;
2093
- /** A `blocker` records what the Task waits on; a note when left out. */
2094
- kind: Schema.optional<Schema.Literals<readonly ["note", "blocker"]>>;
2095
- }>, Schema.Void, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"ReportPipeline", Schema.Struct<{
1981
+ number: Schema.String;
1982
+ head: Schema.String;
1983
+ note: Schema.String;
1984
+ }>, Schema.Struct<{
1985
+ readonly closed: Schema.Boolean;
1986
+ readonly head: Schema.optionalKey<Schema.String>;
1987
+ }>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"RerunPipeline", Schema.Struct<{
2096
1988
  lease: Schema.Struct<{
2097
1989
  readonly workUnitId: Schema.String;
2098
1990
  readonly leaseOwnerId: Schema.String;
@@ -2103,12 +1995,13 @@ export declare const ProgramRpcs: RpcGroup.RpcGroup<Rpc.Rpc<"AdmitChild", Schema
2103
1995
  readonly capacitySlot: Schema.String;
2104
1996
  }>;
2105
1997
  step: Schema.String;
2106
- changeRequestId: Schema.String;
2107
- verification: Schema.String;
1998
+ changeRequestId: Schema.optionalKey<Schema.String>;
1999
+ ref: Schema.optionalKey<Schema.String>;
2000
+ all: Schema.optionalKey<Schema.Boolean>;
2108
2001
  }>, Schema.Struct<{
2109
2002
  readonly head: Schema.String;
2110
- readonly status: Schema.Literals<readonly ["success", "failed"]>;
2111
- }>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"RerunPipeline", Schema.Struct<{
2003
+ readonly pipelines: Schema.Int;
2004
+ }>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"PublishRelease", Schema.Struct<{
2112
2005
  lease: Schema.Struct<{
2113
2006
  readonly workUnitId: Schema.String;
2114
2007
  readonly leaseOwnerId: Schema.String;
@@ -2119,13 +2012,15 @@ export declare const ProgramRpcs: RpcGroup.RpcGroup<Rpc.Rpc<"AdmitChild", Schema
2119
2012
  readonly capacitySlot: Schema.String;
2120
2013
  }>;
2121
2014
  step: Schema.String;
2122
- changeRequestId: Schema.optionalKey<Schema.String>;
2123
- ref: Schema.optionalKey<Schema.String>;
2124
- all: Schema.optionalKey<Schema.Boolean>;
2015
+ tag: Schema.String;
2016
+ revision: Schema.optionalKey<Schema.String>;
2017
+ title: Schema.String;
2018
+ notes: Schema.String;
2125
2019
  }>, Schema.Struct<{
2126
- readonly head: Schema.String;
2127
- readonly pipelines: Schema.Int;
2128
- }>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"ReviewThreads", Schema.Struct<{
2020
+ readonly tag: Schema.String;
2021
+ readonly revision: Schema.String;
2022
+ readonly url: Schema.String;
2023
+ }>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"CreateRunFile", Schema.Struct<{
2129
2024
  lease: Schema.Struct<{
2130
2025
  readonly workUnitId: Schema.String;
2131
2026
  readonly leaseOwnerId: Schema.String;
@@ -2136,19 +2031,40 @@ export declare const ProgramRpcs: RpcGroup.RpcGroup<Rpc.Rpc<"AdmitChild", Schema
2136
2031
  readonly capacitySlot: Schema.String;
2137
2032
  }>;
2138
2033
  step: Schema.String;
2139
- changeRequestId: Schema.String;
2034
+ name: Schema.String;
2035
+ caption: Schema.optional<Schema.String>;
2036
+ contentType: Schema.String;
2037
+ byteSize: Schema.Int;
2038
+ sha256: Schema.String;
2140
2039
  }>, Schema.Struct<{
2141
- readonly threads: Schema.$Array<Schema.Struct<{
2040
+ readonly file: Schema.Struct<{
2142
2041
  readonly id: Schema.String;
2143
- readonly path: Schema.optionalKey<Schema.String>;
2144
- readonly line: Schema.optionalKey<Schema.Int>;
2145
- readonly outdated: Schema.optionalKey<Schema.Boolean>;
2146
- readonly comments: Schema.$Array<Schema.Struct<{
2147
- readonly author: Schema.optionalKey<Schema.String>;
2148
- readonly body: Schema.String;
2042
+ readonly runId: Schema.String;
2043
+ readonly step: Schema.String;
2044
+ readonly name: Schema.String;
2045
+ readonly caption: Schema.optionalKey<Schema.String>;
2046
+ readonly contentType: Schema.String;
2047
+ readonly kind: Schema.Literals<readonly ["image", "video", "html", "text", "other"]>;
2048
+ readonly byteSize: Schema.Int;
2049
+ readonly sha256: Schema.String;
2050
+ readonly status: Schema.Literals<readonly ["uploading", "available", "rejected", "refused", "removing", "removed", "expired"]>;
2051
+ }>;
2052
+ readonly upload: Schema.optional<Schema.Union<readonly [Schema.Struct<{
2053
+ readonly url: Schema.String;
2054
+ readonly headers: Schema.optionalKey<Schema.$Record<Schema.String, Schema.String>>;
2055
+ readonly expiresAt: Schema.String;
2056
+ readonly kind: Schema.Literal<"single">;
2057
+ }>, Schema.Struct<{
2058
+ readonly kind: Schema.Literal<"multipart">;
2059
+ readonly partSize: Schema.Int;
2060
+ readonly parts: Schema.$Array<Schema.Struct<{
2061
+ readonly url: Schema.String;
2062
+ readonly headers: Schema.optionalKey<Schema.$Record<Schema.String, Schema.String>>;
2063
+ readonly expiresAt: Schema.String;
2064
+ readonly partNumber: Schema.Int;
2149
2065
  }>>;
2150
- }>>;
2151
- }>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"RunFileParts", Schema.Struct<{
2066
+ }>]>>;
2067
+ }>, Schema.Union<readonly [typeof RunnerRpcError, typeof RunFileRefused]>, typeof RunnerAuthentication, never> | Rpc.Rpc<"RunFileParts", Schema.Struct<{
2152
2068
  lease: Schema.Struct<{
2153
2069
  readonly workUnitId: Schema.String;
2154
2070
  readonly leaseOwnerId: Schema.String;
@@ -2167,7 +2083,7 @@ export declare const ProgramRpcs: RpcGroup.RpcGroup<Rpc.Rpc<"AdmitChild", Schema
2167
2083
  readonly expiresAt: Schema.String;
2168
2084
  readonly partNumber: Schema.Int;
2169
2085
  }>>;
2170
- }>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"ScheduleClock", Schema.Struct<{
2086
+ }>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"PerformHostEffect", Schema.Struct<{
2171
2087
  lease: Schema.Struct<{
2172
2088
  readonly workUnitId: Schema.String;
2173
2089
  readonly leaseOwnerId: Schema.String;
@@ -2177,10 +2093,33 @@ export declare const ProgramRpcs: RpcGroup.RpcGroup<Rpc.Rpc<"AdmitChild", Schema
2177
2093
  readonly fencingToken: Schema.String;
2178
2094
  readonly capacitySlot: Schema.String;
2179
2095
  }>;
2180
- name: Schema.String;
2181
- deferredName: Schema.String;
2182
- durationMillis: Schema.Int;
2183
- }>, Schema.Void, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"StartAgentStep", Schema.Struct<{
2096
+ step: Schema.String;
2097
+ effect: Schema.Union<readonly [Schema.Struct<{
2098
+ readonly kind: Schema.Literal<"post_comment">;
2099
+ readonly changeRequestId: Schema.String;
2100
+ readonly body: Schema.String;
2101
+ readonly threadId: Schema.optionalKey<Schema.String>;
2102
+ readonly summary: Schema.optionalKey<Schema.String>;
2103
+ readonly anchors: Schema.optionalKey<Schema.$Array<Schema.Struct<{
2104
+ readonly file: Schema.String;
2105
+ readonly line: Schema.Int;
2106
+ readonly body: Schema.String;
2107
+ }>>>;
2108
+ }>, Schema.Struct<{
2109
+ readonly kind: Schema.Literal<"change_request">;
2110
+ readonly title: Schema.String;
2111
+ readonly body: Schema.String;
2112
+ readonly integration: Schema.optionalKey<Schema.String>;
2113
+ }>, Schema.Struct<{
2114
+ readonly kind: Schema.Literal<"write_back">;
2115
+ readonly milestone: Schema.optionalKey<Schema.Literals<readonly ["started", "change_request_opened", "merged", "failed"]>>;
2116
+ readonly changeRequestUrl: Schema.optionalKey<Schema.String>;
2117
+ }>]>;
2118
+ }>, Schema.UndefinedOr<Schema.Struct<{
2119
+ readonly id: Schema.String;
2120
+ readonly number: Schema.String;
2121
+ readonly url: Schema.String;
2122
+ }>>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"ApproveChangeRequest", Schema.Struct<{
2184
2123
  lease: Schema.Struct<{
2185
2124
  readonly workUnitId: Schema.String;
2186
2125
  readonly leaseOwnerId: Schema.String;
@@ -2191,20 +2130,39 @@ export declare const ProgramRpcs: RpcGroup.RpcGroup<Rpc.Rpc<"AdmitChild", Schema
2191
2130
  readonly capacitySlot: Schema.String;
2192
2131
  }>;
2193
2132
  step: Schema.String;
2194
- deferredName: Schema.String;
2195
- role: Schema.String;
2196
- agentId: Schema.String;
2197
- prompt: Schema.String;
2198
- /** The skill the Step runs. */
2199
- skill: Schema.optionalKey<Schema.String>;
2200
- outputSchema: Schema.Codec<Schema.Json, Schema.Json, never, never>;
2201
- secrets: Schema.optionalKey<Schema.$Array<Schema.String>>;
2202
- timeoutMillis: Schema.optionalKey<Schema.Int>;
2203
- /** The branch whose head the Runner merges into the checkout before the agent starts. */
2204
- mergeTarget: Schema.optionalKey<Schema.String>;
2133
+ changeRequestId: Schema.String;
2134
+ head: Schema.String;
2135
+ summary: Schema.String;
2136
+ review: Schema.optionalKey<Schema.String>;
2137
+ carries: Schema.optionalKey<Schema.String>;
2138
+ }>, Schema.Union<readonly [Schema.Struct<{
2139
+ readonly approved: Schema.Literal<true>;
2140
+ readonly reviewId: Schema.String;
2205
2141
  }>, Schema.Struct<{
2206
- readonly stepAttemptId: Schema.String;
2207
- }>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"StartVerification", Schema.Struct<{
2142
+ readonly approved: Schema.Literal<false>;
2143
+ readonly reason: Schema.String;
2144
+ }>]>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"MergeChangeRequest", Schema.Struct<{
2145
+ lease: Schema.Struct<{
2146
+ readonly workUnitId: Schema.String;
2147
+ readonly leaseOwnerId: Schema.String;
2148
+ readonly runnerReplicaId: Schema.String;
2149
+ readonly leaseId: Schema.String;
2150
+ readonly attempt: Schema.Int;
2151
+ readonly fencingToken: Schema.String;
2152
+ readonly capacitySlot: Schema.String;
2153
+ }>;
2154
+ step: Schema.String;
2155
+ changeRequestId: Schema.String;
2156
+ head: Schema.optionalKey<Schema.String>;
2157
+ }>, Schema.Union<readonly [Schema.Struct<{
2158
+ readonly status: Schema.Literal<"merged">;
2159
+ readonly revision: Schema.String;
2160
+ }>, Schema.Struct<{
2161
+ readonly status: Schema.Literal<"conflict">;
2162
+ }>, Schema.Struct<{
2163
+ readonly status: Schema.Literal<"moved">;
2164
+ readonly head: Schema.String;
2165
+ }>]>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"AwaitEvent", Schema.Struct<{
2208
2166
  lease: Schema.Struct<{
2209
2167
  readonly workUnitId: Schema.String;
2210
2168
  readonly leaseOwnerId: Schema.String;
@@ -2216,43 +2174,19 @@ export declare const ProgramRpcs: RpcGroup.RpcGroup<Rpc.Rpc<"AdmitChild", Schema
2216
2174
  }>;
2217
2175
  step: Schema.String;
2218
2176
  deferredName: Schema.String;
2219
- /** The Run's head when left out. */
2220
- revision: Schema.optionalKey<Schema.String>;
2221
- checks: Schema.optional<Schema.$Array<Schema.String>>;
2222
- /** Run, labelled as suggested, when the repository has no approved checks. */
2223
- suggested: Schema.optionalKey<Schema.$Array<Schema.Struct<{
2224
- readonly name: Schema.String;
2225
- readonly command: Schema.String;
2226
- readonly workingDirectory: Schema.optionalKey<Schema.String>;
2227
- readonly suggested: Schema.optionalKey<Schema.Boolean>;
2177
+ event: Schema.String;
2178
+ /** Event payload paths and the value, or any of the values, each must hold. */
2179
+ filter: Schema.optional<Schema.$Record<Schema.String, Schema.Union<readonly [Schema.Union<readonly [Schema.String, Schema.Finite, Schema.Boolean, Schema.Null]>, Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Finite, Schema.Boolean, Schema.Null]>>]>>>;
2180
+ timeoutMillis: Schema.Int;
2181
+ /** An ISO time: a state Event received before it never settles the wait, as a newer read superseded it. */
2182
+ since: Schema.optionalKey<Schema.String>;
2183
+ /** Other Events that settle the wait too, each with its own filter and `since`. */
2184
+ or: Schema.optionalKey<Schema.$Array<Schema.Struct<{
2185
+ readonly event: Schema.String;
2186
+ readonly filter: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Union<readonly [Schema.Union<readonly [Schema.String, Schema.Finite, Schema.Boolean, Schema.Null]>, Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Finite, Schema.Boolean, Schema.Null]>>]>>>;
2187
+ readonly since: Schema.optionalKey<Schema.String>;
2228
2188
  }>>>;
2229
- /** Runs a check again whose evidence at the tree failed, rather than reusing that failure; passed evidence is still reused. */
2230
- rerunFailed: Schema.optionalKey<Schema.Boolean>;
2231
- /** A benchmark against `base` (the Run's base branch head when left out) in place of checks. */
2232
- measure: Schema.optionalKey<Schema.Struct<{
2233
- readonly base: Schema.optionalKey<Schema.String>;
2234
- readonly plan: Schema.Struct<{
2235
- readonly command: Schema.String;
2236
- readonly prepare: Schema.optionalKey<Schema.String>;
2237
- readonly workingDirectory: Schema.optionalKey<Schema.String>;
2238
- readonly warmup: Schema.optionalKey<Schema.Int>;
2239
- readonly metrics: Schema.$Array<Schema.Struct<{
2240
- readonly name: Schema.String;
2241
- readonly direction: Schema.Literals<readonly ["lower", "higher"]>;
2242
- readonly role: Schema.Literals<readonly ["primary", "guardrail"]>;
2243
- readonly lowVariance: Schema.optionalKey<Schema.Boolean>;
2244
- }>>;
2245
- }>;
2246
- readonly samples: Schema.Int;
2247
- readonly calibrate: Schema.Boolean;
2248
- }>>;
2249
- /** Revisions to resolve to commits in place of checks. */
2250
- resolve: Schema.optionalKey<Schema.Struct<{
2251
- readonly revisions: Schema.$Array<Schema.String>;
2252
- }>>;
2253
- }>, Schema.Struct<{
2254
- readonly verificationId: Schema.String;
2255
- }>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"StoreArtifact", Schema.Struct<{
2189
+ }>, Schema.Void, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"ClaimResource", Schema.Struct<{
2256
2190
  lease: Schema.Struct<{
2257
2191
  readonly workUnitId: Schema.String;
2258
2192
  readonly leaseOwnerId: Schema.String;
@@ -2263,14 +2197,10 @@ export declare const ProgramRpcs: RpcGroup.RpcGroup<Rpc.Rpc<"AdmitChild", Schema
2263
2197
  readonly capacitySlot: Schema.String;
2264
2198
  }>;
2265
2199
  step: Schema.String;
2266
- kind: Schema.String;
2267
- title: Schema.String;
2268
- text: Schema.String;
2269
- data: Schema.optional<Schema.Codec<Schema.Json, Schema.Json, never, never>>;
2270
- fileIds: Schema.optional<Schema.$Array<Schema.String>>;
2271
- }>, Schema.Struct<{
2272
- readonly artifactId: Schema.String;
2273
- }>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"Suspend", Schema.Struct<{
2200
+ deferredName: Schema.String;
2201
+ resource: Schema.String;
2202
+ action: Schema.Literals<readonly ["claim", "take_over", "let_go"]>;
2203
+ }>, Schema.Void, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"DeferredDone", Schema.Struct<{
2274
2204
  lease: Schema.Struct<{
2275
2205
  readonly workUnitId: Schema.String;
2276
2206
  readonly leaseOwnerId: Schema.String;
@@ -2280,9 +2210,9 @@ export declare const ProgramRpcs: RpcGroup.RpcGroup<Rpc.Rpc<"AdmitChild", Schema
2280
2210
  readonly fencingToken: Schema.String;
2281
2211
  readonly capacitySlot: Schema.String;
2282
2212
  }>;
2283
- }>, Schema.Void, typeof RunnerRpcError, typeof RunnerAuthentication, never>>;
2284
- /** Every group, served on the one Runner RPC endpoint; a request names its procedure by tag alone. */
2285
- export declare const RunnerRpcs: RpcGroup.RpcGroup<Rpc.Rpc<"AdmitChild", Schema.Struct<{
2213
+ name: Schema.String;
2214
+ exit: Schema.Codec<Schema.Json, Schema.Json, never, never>;
2215
+ }>, Schema.Void, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"FinishProgram", Schema.Struct<{
2286
2216
  lease: Schema.Struct<{
2287
2217
  readonly workUnitId: Schema.String;
2288
2218
  readonly leaseOwnerId: Schema.String;
@@ -2292,15 +2222,14 @@ export declare const RunnerRpcs: RpcGroup.RpcGroup<Rpc.Rpc<"AdmitChild", Schema.
2292
2222
  readonly fencingToken: Schema.String;
2293
2223
  readonly capacitySlot: Schema.String;
2294
2224
  }>;
2295
- step: Schema.String;
2296
- loop: Schema.String;
2297
- input: Schema.Codec<Schema.Json, Schema.Json, never, never>;
2298
- /** Constraints the Child Run's Intent starts with besides its parent's. */
2299
- constraints: Schema.optional<Schema.$Array<Schema.String>>;
2300
- deferredName: Schema.String;
2301
- }>, Schema.Struct<{
2302
- readonly runId: Schema.String;
2303
- }>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"AlertTask", Schema.Struct<{
2225
+ outcome: Schema.Union<readonly [Schema.Struct<{
2226
+ readonly status: Schema.Literal<"completed">;
2227
+ readonly output: Schema.Codec<Schema.Json, Schema.Json, never, never>;
2228
+ }>, Schema.Struct<{
2229
+ readonly status: Schema.Literal<"failed">;
2230
+ readonly failureSummary: Schema.String;
2231
+ }>]>;
2232
+ }>, Schema.Void, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"RecordActivity", Schema.Struct<{
2304
2233
  lease: Schema.Struct<{
2305
2234
  readonly workUnitId: Schema.String;
2306
2235
  readonly leaseOwnerId: Schema.String;
@@ -2310,65 +2239,10 @@ export declare const RunnerRpcs: RpcGroup.RpcGroup<Rpc.Rpc<"AdmitChild", Schema.
2310
2239
  readonly fencingToken: Schema.String;
2311
2240
  readonly capacitySlot: Schema.String;
2312
2241
  }>;
2313
- step: Schema.String;
2314
- fingerprint: Schema.String;
2315
- title: Schema.String;
2316
- windowHours: Schema.Int;
2317
- resolved: Schema.optionalKey<Schema.Boolean>;
2318
- priority: Schema.optionalKey<Schema.Literals<readonly ["urgent", "high", "medium", "low"]>>;
2319
- }>, Schema.Struct<{
2320
- readonly taskId: Schema.optionalKey<Schema.String>;
2321
- readonly created: Schema.Boolean;
2322
- readonly resolved: Schema.optionalKey<Schema.Boolean>;
2323
- readonly joined: Schema.optionalKey<Schema.Struct<{
2324
- readonly kind: Schema.Literals<readonly ["run", "recent"]>;
2325
- readonly runId: Schema.String;
2326
- }>>;
2327
- }>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"AppendTranscript", Schema.Struct<{
2328
- workUnitId: Schema.String;
2329
- entries: Schema.$Array<Schema.Struct<{
2330
- readonly sequence: Schema.Int;
2331
- readonly event: Schema.Union<readonly [Schema.Struct<{
2332
- readonly kind: Schema.Literal<"message">;
2333
- readonly role: Schema.Literals<readonly ["assistant", "user"]>;
2334
- readonly text: Schema.String;
2335
- }>, Schema.Struct<{
2336
- readonly kind: Schema.Literal<"tool_call">;
2337
- readonly callId: Schema.String;
2338
- readonly name: Schema.String;
2339
- readonly arguments: Schema.Codec<Schema.Json, Schema.Json, never, never>;
2340
- }>, Schema.Struct<{
2341
- readonly kind: Schema.Literal<"tool_result">;
2342
- readonly callId: Schema.String;
2343
- readonly output: Schema.String;
2344
- readonly isError: Schema.optionalKey<Schema.Boolean>;
2345
- }>, Schema.Struct<{
2346
- readonly kind: Schema.Literal<"file">;
2347
- readonly path: Schema.String;
2348
- readonly change: Schema.Literals<readonly ["read", "changed"]>;
2349
- }>, Schema.Struct<{
2350
- readonly kind: Schema.Literal<"question">;
2351
- readonly text: Schema.String;
2352
- }>, Schema.Struct<{
2353
- readonly kind: Schema.Literal<"answer">;
2354
- readonly callId: Schema.optionalKey<Schema.String>;
2355
- readonly questionId: Schema.optionalKey<Schema.String>;
2356
- readonly text: Schema.String;
2357
- }>, Schema.Struct<{
2358
- readonly kind: Schema.Literal<"steer">;
2359
- readonly messageId: Schema.String;
2360
- readonly text: Schema.String;
2361
- }>, Schema.Struct<{
2362
- readonly kind: Schema.Literal<"secret_refused">;
2363
- readonly reference: Schema.optionalKey<Schema.String>;
2364
- readonly host: Schema.String;
2365
- readonly reason: Schema.String;
2366
- }>, Schema.Struct<{
2367
- readonly kind: Schema.Literal<"lifecycle">;
2368
- readonly state: Schema.Literals<readonly ["started", "resumed", "parked", "finished", "failed", "canceled"]>;
2369
- }>]>;
2370
- }>>;
2371
- }>, Schema.Void, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"ApproveChangeRequest", Schema.Struct<{
2242
+ name: Schema.String;
2243
+ attempt: Schema.Int;
2244
+ exit: Schema.Codec<Schema.Json, Schema.Json, never, never>;
2245
+ }>, Schema.Void, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"RecordNote", Schema.Struct<{
2372
2246
  lease: Schema.Struct<{
2373
2247
  readonly workUnitId: Schema.String;
2374
2248
  readonly leaseOwnerId: Schema.String;
@@ -2379,18 +2253,11 @@ export declare const RunnerRpcs: RpcGroup.RpcGroup<Rpc.Rpc<"AdmitChild", Schema.
2379
2253
  readonly capacitySlot: Schema.String;
2380
2254
  }>;
2381
2255
  step: Schema.String;
2382
- changeRequestId: Schema.String;
2383
- head: Schema.String;
2384
- summary: Schema.String;
2385
- review: Schema.optionalKey<Schema.String>;
2386
- carries: Schema.optionalKey<Schema.String>;
2387
- }>, Schema.Union<readonly [Schema.Struct<{
2388
- readonly approved: Schema.Literal<true>;
2389
- readonly reviewId: Schema.String;
2390
- }>, Schema.Struct<{
2391
- readonly approved: Schema.Literal<false>;
2392
- readonly reason: Schema.String;
2393
- }>]>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"AwaitEvent", Schema.Struct<{
2256
+ text: Schema.String;
2257
+ artifactId: Schema.optional<Schema.String>;
2258
+ /** A `blocker` records what the Task waits on; a note when left out. */
2259
+ kind: Schema.optional<Schema.Literals<readonly ["note", "blocker"]>>;
2260
+ }>, Schema.Void, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"ScheduleClock", Schema.Struct<{
2394
2261
  lease: Schema.Struct<{
2395
2262
  readonly workUnitId: Schema.String;
2396
2263
  readonly leaseOwnerId: Schema.String;
@@ -2400,25 +2267,10 @@ export declare const RunnerRpcs: RpcGroup.RpcGroup<Rpc.Rpc<"AdmitChild", Schema.
2400
2267
  readonly fencingToken: Schema.String;
2401
2268
  readonly capacitySlot: Schema.String;
2402
2269
  }>;
2403
- step: Schema.String;
2270
+ name: Schema.String;
2404
2271
  deferredName: Schema.String;
2405
- event: Schema.String;
2406
- /** Event payload paths and the value, or any of the values, each must hold. */
2407
- filter: Schema.optional<Schema.$Record<Schema.String, Schema.Union<readonly [Schema.Union<readonly [Schema.String, Schema.Finite, Schema.Boolean, Schema.Null]>, Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Finite, Schema.Boolean, Schema.Null]>>]>>>;
2408
- timeoutMillis: Schema.Int;
2409
- /** An ISO time: a state Event received before it never settles the wait, as a newer read superseded it. */
2410
- since: Schema.optionalKey<Schema.String>;
2411
- /** Other Events that settle the wait too, each with its own filter and `since`. */
2412
- or: Schema.optionalKey<Schema.$Array<Schema.Struct<{
2413
- readonly event: Schema.String;
2414
- readonly filter: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Union<readonly [Schema.Union<readonly [Schema.String, Schema.Finite, Schema.Boolean, Schema.Null]>, Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Finite, Schema.Boolean, Schema.Null]>>]>>>;
2415
- readonly since: Schema.optionalKey<Schema.String>;
2416
- }>>>;
2417
- }>, Schema.Void, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"Bundle", Schema.Struct<{
2418
- digest: Schema.String;
2419
- }>, Schema.Struct<{
2420
- readonly bundle: Schema.String;
2421
- }>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"CheckpointFileParts", Schema.Struct<{
2272
+ durationMillis: Schema.Int;
2273
+ }>, Schema.Void, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"Suspend", Schema.Struct<{
2422
2274
  lease: Schema.Struct<{
2423
2275
  readonly workUnitId: Schema.String;
2424
2276
  readonly leaseOwnerId: Schema.String;
@@ -2428,16 +2280,91 @@ export declare const RunnerRpcs: RpcGroup.RpcGroup<Rpc.Rpc<"AdmitChild", Schema.
2428
2280
  readonly fencingToken: Schema.String;
2429
2281
  readonly capacitySlot: Schema.String;
2430
2282
  }>;
2431
- fileId: Schema.String;
2432
- partNumbers: Schema.$Array<Schema.Int>;
2433
- }>, Schema.Struct<{
2434
- readonly parts: Schema.$Array<Schema.Struct<{
2435
- readonly url: Schema.String;
2436
- readonly headers: Schema.optionalKey<Schema.$Record<Schema.String, Schema.String>>;
2437
- readonly expiresAt: Schema.String;
2438
- readonly partNumber: Schema.Int;
2283
+ }>, Schema.Void, typeof RunnerRpcError, typeof RunnerAuthentication, never>>;
2284
+ /** Every group, served on the one Runner RPC endpoint; a request names its procedure by tag alone. */
2285
+ export declare const RunnerRpcs: RpcGroup.RpcGroup<Rpc.Rpc<"SettledRuns", Schema.Struct<{
2286
+ runIds: Schema.$Array<Schema.String>;
2287
+ }>, Schema.$Array<Schema.String>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"SettledCheckpoints", Schema.Void, Schema.$Array<Schema.Struct<{
2288
+ readonly stepAttemptId: Schema.String;
2289
+ readonly ref: Schema.optionalKey<Schema.String>;
2290
+ readonly repoBinding: Schema.optionalKey<Schema.Struct<{
2291
+ readonly id: Schema.String;
2292
+ readonly provider: Schema.Literals<readonly ["github", "gitlab", "forgejo", "gitea", "gitee", "bitbucket", "azure-devops", "generic_git"]>;
2293
+ readonly host: Schema.String;
2294
+ readonly owner: Schema.String;
2295
+ readonly name: Schema.String;
2296
+ readonly repositoryUrl: Schema.optionalKey<Schema.String>;
2297
+ readonly pathPrefix: Schema.optionalKey<Schema.String>;
2298
+ readonly defaultTargetBranch: Schema.String;
2299
+ readonly expectedBranch: Schema.optionalKey<Schema.String>;
2300
+ readonly expectedCommitSha: Schema.optionalKey<Schema.String>;
2301
+ }>>;
2302
+ }>>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"KnownEvidence", Schema.Struct<{
2303
+ lease: Schema.Struct<{
2304
+ readonly workUnitId: Schema.String;
2305
+ readonly leaseOwnerId: Schema.String;
2306
+ readonly runnerReplicaId: Schema.String;
2307
+ readonly leaseId: Schema.String;
2308
+ readonly attempt: Schema.Int;
2309
+ readonly fencingToken: Schema.String;
2310
+ readonly capacitySlot: Schema.String;
2311
+ }>;
2312
+ trees: Schema.$Array<Schema.String>;
2313
+ }>, Schema.$Array<Schema.Struct<{
2314
+ readonly tree: Schema.String;
2315
+ readonly name: Schema.String;
2316
+ readonly command: Schema.String;
2317
+ }>>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"CreatePlanTasks", Schema.Struct<{
2318
+ lease: Schema.Struct<{
2319
+ readonly workUnitId: Schema.String;
2320
+ readonly leaseOwnerId: Schema.String;
2321
+ readonly runnerReplicaId: Schema.String;
2322
+ readonly leaseId: Schema.String;
2323
+ readonly attempt: Schema.Int;
2324
+ readonly fencingToken: Schema.String;
2325
+ readonly capacitySlot: Schema.String;
2326
+ }>;
2327
+ projectId: Schema.optionalKey<Schema.String>;
2328
+ tickets: Schema.$Array<Schema.Struct<{
2329
+ readonly key: Schema.String;
2330
+ readonly title: Schema.String;
2331
+ readonly body: Schema.String;
2332
+ readonly acceptanceCriteria: Schema.$Array<Schema.String>;
2333
+ readonly blockedBy: Schema.$Array<Schema.String>;
2334
+ readonly outcome: Schema.optionalKey<Schema.Literals<readonly ["feature", "bug", "refactor", "investigation", "docs", "migration", "performance"]>>;
2439
2335
  }>>;
2440
- }>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"Claim", Schema.Struct<{
2336
+ }>, Schema.$Array<Schema.Struct<{
2337
+ readonly key: Schema.String;
2338
+ readonly taskId: Schema.String;
2339
+ }>>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"ProgramSecrets", Schema.Struct<{
2340
+ lease: Schema.Struct<{
2341
+ readonly workUnitId: Schema.String;
2342
+ readonly leaseOwnerId: Schema.String;
2343
+ readonly runnerReplicaId: Schema.String;
2344
+ readonly leaseId: Schema.String;
2345
+ readonly attempt: Schema.Int;
2346
+ readonly fencingToken: Schema.String;
2347
+ readonly capacitySlot: Schema.String;
2348
+ }>;
2349
+ }>, Schema.$Record<Schema.String, Schema.String>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"Signals", Schema.Struct<{
2350
+ runnerReplicaId: Schema.String;
2351
+ }>, import("effect/rpc/RpcSchema").Stream<Schema.Union<readonly [Schema.TaggedStruct<"WorkAvailable", {}>, Schema.TaggedStruct<"LeaseRevoked", {
2352
+ readonly workUnitId: Schema.String;
2353
+ }>, Schema.TaggedStruct<"Settled", {
2354
+ readonly workUnitId: Schema.String;
2355
+ }>, Schema.TaggedStruct<"Canceled", {
2356
+ readonly workUnitId: Schema.String;
2357
+ }>, Schema.TaggedStruct<"RunSettled", {
2358
+ readonly runId: Schema.String;
2359
+ }>, Schema.TaggedStruct<"Steer", {
2360
+ readonly workUnitId: Schema.String;
2361
+ readonly messageId: Schema.String;
2362
+ readonly text: Schema.String;
2363
+ }>, Schema.TaggedStruct<"SessionUpdated", {
2364
+ readonly workUnitId: Schema.String;
2365
+ }>, Schema.TaggedStruct<"UpdateAvailable", {
2366
+ readonly version: Schema.String;
2367
+ }>]>, typeof RunnerRpcError>, Schema.Never, typeof RunnerAuthentication, never> | Rpc.Rpc<"Claim", Schema.Struct<{
2441
2368
  readonly teamId: Schema.optionalKey<Schema.String>;
2442
2369
  readonly runnerReplicaId: Schema.String;
2443
2370
  readonly capacitySlot: Schema.String;
@@ -2605,9 +2532,9 @@ export declare const RunnerRpcs: RpcGroup.RpcGroup<Rpc.Rpc<"AdmitChild", Schema.
2605
2532
  readonly hosts: Schema.optionalKey<Schema.$Array<Schema.String>>;
2606
2533
  readonly storageOrigin: Schema.optionalKey<Schema.String>;
2607
2534
  }>]>>;
2608
- }>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"ClaimResource", Schema.Struct<{
2609
- lease: Schema.Struct<{
2610
- readonly workUnitId: Schema.String;
2535
+ }>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"Heartbeat", Schema.Struct<{
2536
+ readonly workUnitId: Schema.String;
2537
+ readonly lease: Schema.Struct<{
2611
2538
  readonly leaseOwnerId: Schema.String;
2612
2539
  readonly runnerReplicaId: Schema.String;
2613
2540
  readonly leaseId: Schema.String;
@@ -2615,144 +2542,18 @@ export declare const RunnerRpcs: RpcGroup.RpcGroup<Rpc.Rpc<"AdmitChild", Schema.
2615
2542
  readonly fencingToken: Schema.String;
2616
2543
  readonly capacitySlot: Schema.String;
2617
2544
  }>;
2618
- step: Schema.String;
2619
- deferredName: Schema.String;
2620
- resource: Schema.String;
2621
- action: Schema.Literals<readonly ["claim", "take_over", "let_go"]>;
2622
- }>, Schema.Void, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"CloseChangeRequest", Schema.Struct<{
2623
- lease: Schema.Struct<{
2624
- readonly workUnitId: Schema.String;
2625
- readonly leaseOwnerId: Schema.String;
2626
- readonly runnerReplicaId: Schema.String;
2627
- readonly leaseId: Schema.String;
2628
- readonly attempt: Schema.Int;
2629
- readonly fencingToken: Schema.String;
2630
- readonly capacitySlot: Schema.String;
2631
- }>;
2632
- step: Schema.String;
2633
- number: Schema.String;
2634
- head: Schema.String;
2635
- note: Schema.String;
2636
- }>, Schema.Struct<{
2637
- readonly closed: Schema.Boolean;
2638
- readonly head: Schema.optionalKey<Schema.String>;
2639
- }>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"Complete", Schema.Struct<{
2640
- readonly workUnitId: Schema.String;
2641
- readonly lease: Schema.Struct<{
2642
- readonly leaseOwnerId: Schema.String;
2643
- readonly runnerReplicaId: Schema.String;
2644
- readonly leaseId: Schema.String;
2645
- readonly attempt: Schema.Int;
2646
- readonly fencingToken: Schema.String;
2647
- readonly capacitySlot: Schema.String;
2648
- }>;
2649
- readonly idempotencyKey: Schema.String;
2650
- readonly outcome: Schema.Struct<{
2651
- readonly status: Schema.Union<readonly [Schema.Literal<"completed">, Schema.Literal<"failed">, Schema.Literal<"blocked">, Schema.Literal<"canceled">]>;
2652
- readonly result: Schema.optionalKey<Schema.Struct<{
2653
- readonly stepKey: Schema.String;
2654
- readonly outputSchemaRef: Schema.Struct<{
2655
- readonly kind: Schema.Literal<"typebox_ref">;
2656
- readonly name: Schema.String;
2657
- readonly version: Schema.optionalKey<Schema.String>;
2658
- readonly sha256: Schema.optionalKey<Schema.String>;
2659
- }>;
2660
- readonly summary: Schema.String;
2661
- readonly data: Schema.$Record<Schema.String, Schema.Codec<import("../../../core/src/index").LoopStepOutputDataValue, import("../../../core/src/index").LoopStepOutputDataValue, never, never>>;
2662
- readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<import("../../../core/src/index").LoopStepOutputDataValue, import("../../../core/src/index").LoopStepOutputDataValue, never, never>>>;
2663
- readonly refs: Schema.$Array<Schema.Struct<{
2664
- readonly kind: Schema.Literals<readonly ["task", "kit", "memory", "decision", "knowledge_record", "context_pack", "step_attempt", "change_request", "change_request_review", "provider_action", "thread_entry", "run", "artifact"]>;
2665
- readonly id: Schema.optionalKey<Schema.String>;
2666
- readonly externalId: Schema.optionalKey<Schema.String>;
2667
- readonly provider: Schema.optionalKey<Schema.String>;
2668
- readonly title: Schema.optionalKey<Schema.String>;
2669
- }>>;
2670
- }>>;
2671
- readonly revision: Schema.optionalKey<Schema.String>;
2672
- readonly evidence: Schema.optionalKey<Schema.Struct<{
2673
- readonly head: Schema.Struct<{
2674
- readonly revision: Schema.String;
2675
- readonly tree: Schema.String;
2676
- readonly checks: Schema.$Array<Schema.Struct<{
2677
- readonly name: Schema.String;
2678
- readonly command: Schema.String;
2679
- readonly status: Schema.Union<readonly [Schema.Literal<"passed">, Schema.Literal<"failed">]>;
2680
- readonly exitCode: Schema.optionalKey<Schema.Int>;
2681
- readonly durationMs: Schema.Int;
2682
- readonly outputTail: Schema.String;
2683
- readonly fileIds: Schema.optionalKey<Schema.$Array<Schema.String>>;
2684
- readonly tests: Schema.optionalKey<Schema.Struct<{
2685
- readonly reports: Schema.Int;
2686
- readonly passed: Schema.Int;
2687
- readonly failed: Schema.Int;
2688
- readonly skipped: Schema.Int;
2689
- readonly skippedTests: Schema.$Array<Schema.String>;
2690
- readonly ranDigests: Schema.$Array<Schema.String>;
2691
- }>>;
2692
- }>>;
2693
- }>;
2694
- readonly baseline: Schema.optionalKey<Schema.Struct<{
2695
- readonly revision: Schema.String;
2696
- readonly tree: Schema.String;
2697
- readonly checks: Schema.$Array<Schema.Struct<{
2698
- readonly name: Schema.String;
2699
- readonly command: Schema.String;
2700
- readonly status: Schema.Union<readonly [Schema.Literal<"passed">, Schema.Literal<"failed">]>;
2701
- readonly exitCode: Schema.optionalKey<Schema.Int>;
2702
- readonly durationMs: Schema.Int;
2703
- readonly outputTail: Schema.String;
2704
- readonly fileIds: Schema.optionalKey<Schema.$Array<Schema.String>>;
2705
- readonly tests: Schema.optionalKey<Schema.Struct<{
2706
- readonly reports: Schema.Int;
2707
- readonly passed: Schema.Int;
2708
- readonly failed: Schema.Int;
2709
- readonly skipped: Schema.Int;
2710
- readonly skippedTests: Schema.$Array<Schema.String>;
2711
- readonly ranDigests: Schema.$Array<Schema.String>;
2712
- }>>;
2713
- }>>;
2714
- }>>;
2715
- readonly measurement: Schema.optionalKey<Schema.Struct<{
2716
- readonly base: Schema.$Array<Schema.$Record<Schema.String, Schema.Finite>>;
2717
- readonly head: Schema.$Array<Schema.$Record<Schema.String, Schema.Finite>>;
2718
- readonly baseAgain: Schema.optionalKey<Schema.$Array<Schema.$Record<Schema.String, Schema.Finite>>>;
2719
- }>>;
2720
- readonly resolved: Schema.optionalKey<Schema.Struct<{
2721
- readonly commits: Schema.$Array<Schema.String>;
2722
- }>>;
2723
- }>>;
2724
- readonly boundary: Schema.optionalKey<Schema.Struct<{
2725
- readonly kind: Schema.Literal<"change">;
2726
- readonly changedPaths: Schema.$Array<Schema.String>;
2727
- readonly omittedPaths: Schema.Int;
2728
- readonly files: Schema.$Array<Schema.Struct<{
2729
- readonly path: Schema.String;
2730
- readonly excerpt: Schema.String;
2731
- readonly redacted: Schema.Boolean;
2732
- readonly truncated: Schema.Boolean;
2733
- }>>;
2734
- readonly truncated: Schema.Boolean;
2735
- }>>;
2736
- readonly catchUp: Schema.optionalKey<Schema.Struct<{
2737
- readonly from: Schema.String;
2738
- readonly head: Schema.String;
2739
- readonly conflicted: Schema.$Array<Schema.String>;
2740
- readonly rewritten: Schema.$Array<Schema.String>;
2741
- readonly changed: Schema.$Array<Schema.String>;
2742
- readonly truncated: Schema.Boolean;
2743
- }>>;
2744
- readonly syncedTarget: Schema.optionalKey<Schema.String>;
2745
- readonly harnessHold: Schema.optionalKey<Schema.Struct<{
2746
- readonly reason: Schema.Literals<readonly ["out_of_quota", "rate_limited", "login_refused", "failed_to_start"]>;
2747
- readonly until: Schema.optionalKey<Schema.String>;
2748
- readonly scope: Schema.optionalKey<Schema.Literal<"step">>;
2749
- }>>;
2750
- readonly restart: Schema.optionalKey<Schema.Struct<{
2751
- readonly reason: Schema.Literal<"login_revoked">;
2752
- }>>;
2753
- readonly failureSummary: Schema.optionalKey<Schema.String>;
2754
- }>;
2755
- }>, Schema.Void, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"CompleteCheckpointFile", Schema.Struct<{
2545
+ readonly leaseDurationSeconds: Schema.optionalKey<Schema.Int>;
2546
+ readonly secrets: Schema.optionalKey<Schema.$Array<Schema.Struct<{
2547
+ readonly name: Schema.String;
2548
+ readonly version: Schema.String;
2549
+ }>>>;
2550
+ }>, Schema.Struct<{
2551
+ readonly settled: Schema.Boolean;
2552
+ readonly outputSubmitted: Schema.optionalKey<Schema.Boolean>;
2553
+ readonly outputMerged: Schema.optionalKey<Schema.Boolean>;
2554
+ readonly questionOpen: Schema.optionalKey<Schema.Boolean>;
2555
+ readonly revokedSecrets: Schema.optionalKey<Schema.$Array<Schema.String>>;
2556
+ }>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"CompleteCheckpointFile", Schema.Struct<{
2756
2557
  lease: Schema.Struct<{
2757
2558
  readonly workUnitId: Schema.String;
2758
2559
  readonly leaseOwnerId: Schema.String;
@@ -2844,29 +2645,7 @@ export declare const RunnerRpcs: RpcGroup.RpcGroup<Rpc.Rpc<"AdmitChild", Schema.
2844
2645
  readonly partNumber: Schema.Int;
2845
2646
  }>>;
2846
2647
  }>]>>;
2847
- }>, Schema.Union<readonly [typeof RunnerRpcError, typeof RunFileRefused]>, typeof RunnerAuthentication, never> | Rpc.Rpc<"CreatePlanTasks", Schema.Struct<{
2848
- lease: Schema.Struct<{
2849
- readonly workUnitId: Schema.String;
2850
- readonly leaseOwnerId: Schema.String;
2851
- readonly runnerReplicaId: Schema.String;
2852
- readonly leaseId: Schema.String;
2853
- readonly attempt: Schema.Int;
2854
- readonly fencingToken: Schema.String;
2855
- readonly capacitySlot: Schema.String;
2856
- }>;
2857
- projectId: Schema.optionalKey<Schema.String>;
2858
- tickets: Schema.$Array<Schema.Struct<{
2859
- readonly key: Schema.String;
2860
- readonly title: Schema.String;
2861
- readonly body: Schema.String;
2862
- readonly acceptanceCriteria: Schema.$Array<Schema.String>;
2863
- readonly blockedBy: Schema.$Array<Schema.String>;
2864
- readonly outcome: Schema.optionalKey<Schema.Literals<readonly ["feature", "bug", "refactor", "investigation", "docs", "migration", "performance"]>>;
2865
- }>>;
2866
- }>, Schema.$Array<Schema.Struct<{
2867
- readonly key: Schema.String;
2868
- readonly taskId: Schema.String;
2869
- }>>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"CreateRunFile", Schema.Struct<{
2648
+ }>, Schema.Union<readonly [typeof RunnerRpcError, typeof RunFileRefused]>, typeof RunnerAuthentication, never> | Rpc.Rpc<"CheckpointFileParts", Schema.Struct<{
2870
2649
  lease: Schema.Struct<{
2871
2650
  readonly workUnitId: Schema.String;
2872
2651
  readonly leaseOwnerId: Schema.String;
@@ -2876,41 +2655,20 @@ export declare const RunnerRpcs: RpcGroup.RpcGroup<Rpc.Rpc<"AdmitChild", Schema.
2876
2655
  readonly fencingToken: Schema.String;
2877
2656
  readonly capacitySlot: Schema.String;
2878
2657
  }>;
2879
- step: Schema.String;
2880
- name: Schema.String;
2881
- caption: Schema.optional<Schema.String>;
2882
- contentType: Schema.String;
2883
- byteSize: Schema.Int;
2884
- sha256: Schema.String;
2658
+ fileId: Schema.String;
2659
+ partNumbers: Schema.$Array<Schema.Int>;
2885
2660
  }>, Schema.Struct<{
2886
- readonly file: Schema.Struct<{
2887
- readonly id: Schema.String;
2888
- readonly runId: Schema.String;
2889
- readonly step: Schema.String;
2890
- readonly name: Schema.String;
2891
- readonly caption: Schema.optionalKey<Schema.String>;
2892
- readonly contentType: Schema.String;
2893
- readonly kind: Schema.Literals<readonly ["image", "video", "html", "text", "other"]>;
2894
- readonly byteSize: Schema.Int;
2895
- readonly sha256: Schema.String;
2896
- readonly status: Schema.Literals<readonly ["uploading", "available", "rejected", "refused", "removing", "removed", "expired"]>;
2897
- }>;
2898
- readonly upload: Schema.optional<Schema.Union<readonly [Schema.Struct<{
2661
+ readonly parts: Schema.$Array<Schema.Struct<{
2899
2662
  readonly url: Schema.String;
2900
2663
  readonly headers: Schema.optionalKey<Schema.$Record<Schema.String, Schema.String>>;
2901
2664
  readonly expiresAt: Schema.String;
2902
- readonly kind: Schema.Literal<"single">;
2903
- }>, Schema.Struct<{
2904
- readonly kind: Schema.Literal<"multipart">;
2905
- readonly partSize: Schema.Int;
2906
- readonly parts: Schema.$Array<Schema.Struct<{
2907
- readonly url: Schema.String;
2908
- readonly headers: Schema.optionalKey<Schema.$Record<Schema.String, Schema.String>>;
2909
- readonly expiresAt: Schema.String;
2910
- readonly partNumber: Schema.Int;
2911
- }>>;
2912
- }>]>>;
2913
- }>, Schema.Union<readonly [typeof RunnerRpcError, typeof RunFileRefused]>, typeof RunnerAuthentication, never> | Rpc.Rpc<"DeferredDone", Schema.Struct<{
2665
+ readonly partNumber: Schema.Int;
2666
+ }>>;
2667
+ }>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"Bundle", Schema.Struct<{
2668
+ digest: Schema.String;
2669
+ }>, Schema.Struct<{
2670
+ readonly bundle: Schema.String;
2671
+ }>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"PutQuestion", Schema.Struct<{
2914
2672
  lease: Schema.Struct<{
2915
2673
  readonly workUnitId: Schema.String;
2916
2674
  readonly leaseOwnerId: Schema.String;
@@ -2920,9 +2678,30 @@ export declare const RunnerRpcs: RpcGroup.RpcGroup<Rpc.Rpc<"AdmitChild", Schema.
2920
2678
  readonly fencingToken: Schema.String;
2921
2679
  readonly capacitySlot: Schema.String;
2922
2680
  }>;
2923
- name: Schema.String;
2924
- exit: Schema.Codec<Schema.Json, Schema.Json, never, never>;
2925
- }>, Schema.Void, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"DraftUpdate", Schema.Struct<{
2681
+ step: Schema.String;
2682
+ prompt: Schema.String;
2683
+ options: Schema.optional<Schema.$Array<Schema.String>>;
2684
+ optionDescriptions: Schema.optional<Schema.$Record<Schema.String, Schema.String>>;
2685
+ recommended: Schema.optional<Schema.String>;
2686
+ recommendationReason: Schema.optional<Schema.String>;
2687
+ informationOnly: Schema.optional<Schema.Boolean>;
2688
+ /** Approving the Question approves this verification for the Run's repository. */
2689
+ verification: Schema.optional<Schema.Struct<{
2690
+ readonly name: Schema.String;
2691
+ readonly command: Schema.String;
2692
+ readonly workingDirectory: Schema.optional<Schema.String>;
2693
+ }>>;
2694
+ /** Taken when the Run is unattended, or when nobody answers within `timeoutMillis`. */
2695
+ default: Schema.optional<Schema.String>;
2696
+ /** Taken at once when the Run's Team delivers in full auto. */
2697
+ auto: Schema.optional<Schema.String>;
2698
+ /** Taken at once when the Run's Team delivers in full auto and nobody attends the Run. */
2699
+ unattendedAuto: Schema.optional<Schema.String>;
2700
+ timeoutMillis: Schema.optional<Schema.Finite>;
2701
+ deferredName: Schema.String;
2702
+ }>, Schema.Struct<{
2703
+ readonly questionId: Schema.String;
2704
+ }>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"StartAgentStep", Schema.Struct<{
2926
2705
  lease: Schema.Struct<{
2927
2706
  readonly workUnitId: Schema.String;
2928
2707
  readonly leaseOwnerId: Schema.String;
@@ -2933,17 +2712,20 @@ export declare const RunnerRpcs: RpcGroup.RpcGroup<Rpc.Rpc<"AdmitChild", Schema.
2933
2712
  readonly capacitySlot: Schema.String;
2934
2713
  }>;
2935
2714
  step: Schema.String;
2936
- projectId: Schema.String;
2937
- health: Schema.Literals<readonly ["on_track", "at_risk", "off_track"]>;
2938
- note: Schema.String;
2939
- writtenFrom: Schema.Struct<{
2940
- readonly runs: Schema.Int;
2941
- readonly taskChanges: Schema.Int;
2942
- readonly since: Schema.optionalKey<Schema.String>;
2943
- }>;
2715
+ deferredName: Schema.String;
2716
+ role: Schema.String;
2717
+ agentId: Schema.String;
2718
+ prompt: Schema.String;
2719
+ /** The skill the Step runs. */
2720
+ skill: Schema.optionalKey<Schema.String>;
2721
+ outputSchema: Schema.Codec<Schema.Json, Schema.Json, never, never>;
2722
+ secrets: Schema.optionalKey<Schema.$Array<Schema.String>>;
2723
+ timeoutMillis: Schema.optionalKey<Schema.Int>;
2724
+ /** The branch whose head the Runner merges into the checkout before the agent starts. */
2725
+ mergeTarget: Schema.optionalKey<Schema.String>;
2944
2726
  }>, Schema.Struct<{
2945
- readonly id: Schema.String;
2946
- }>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"FinishProgram", Schema.Struct<{
2727
+ readonly stepAttemptId: Schema.String;
2728
+ }>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"StartVerification", Schema.Struct<{
2947
2729
  lease: Schema.Struct<{
2948
2730
  readonly workUnitId: Schema.String;
2949
2731
  readonly leaseOwnerId: Schema.String;
@@ -2953,42 +2735,45 @@ export declare const RunnerRpcs: RpcGroup.RpcGroup<Rpc.Rpc<"AdmitChild", Schema.
2953
2735
  readonly fencingToken: Schema.String;
2954
2736
  readonly capacitySlot: Schema.String;
2955
2737
  }>;
2956
- outcome: Schema.Union<readonly [Schema.Struct<{
2957
- readonly status: Schema.Literal<"completed">;
2958
- readonly output: Schema.Codec<Schema.Json, Schema.Json, never, never>;
2959
- }>, Schema.Struct<{
2960
- readonly status: Schema.Literal<"failed">;
2961
- readonly failureSummary: Schema.String;
2962
- }>]>;
2963
- }>, Schema.Void, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"ForgetCheckpoints", Schema.Struct<{
2964
- stepAttemptIds: Schema.$Array<Schema.String>;
2965
- }>, Schema.Void, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"GitCredential", Schema.Struct<{
2966
- repoBindingId: Schema.String;
2967
- }>, Schema.UndefinedOr<Schema.Struct<{
2968
- readonly username: Schema.String;
2969
- readonly password: Schema.String;
2970
- }>>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"Heartbeat", Schema.Struct<{
2971
- readonly workUnitId: Schema.String;
2972
- readonly lease: Schema.Struct<{
2973
- readonly leaseOwnerId: Schema.String;
2974
- readonly runnerReplicaId: Schema.String;
2975
- readonly leaseId: Schema.String;
2976
- readonly attempt: Schema.Int;
2977
- readonly fencingToken: Schema.String;
2978
- readonly capacitySlot: Schema.String;
2979
- }>;
2980
- readonly leaseDurationSeconds: Schema.optionalKey<Schema.Int>;
2981
- readonly secrets: Schema.optionalKey<Schema.$Array<Schema.Struct<{
2738
+ step: Schema.String;
2739
+ deferredName: Schema.String;
2740
+ /** The Run's head when left out. */
2741
+ revision: Schema.optionalKey<Schema.String>;
2742
+ checks: Schema.optional<Schema.$Array<Schema.String>>;
2743
+ /** Run, labelled as suggested, when the repository has no approved checks. */
2744
+ suggested: Schema.optionalKey<Schema.$Array<Schema.Struct<{
2982
2745
  readonly name: Schema.String;
2983
- readonly version: Schema.String;
2746
+ readonly command: Schema.String;
2747
+ readonly workingDirectory: Schema.optionalKey<Schema.String>;
2748
+ readonly suggested: Schema.optionalKey<Schema.Boolean>;
2984
2749
  }>>>;
2750
+ /** Runs a check again whose evidence at the tree failed, rather than reusing that failure; passed evidence is still reused. */
2751
+ rerunFailed: Schema.optionalKey<Schema.Boolean>;
2752
+ /** A benchmark against `base` (the Run's base branch head when left out) in place of checks. */
2753
+ measure: Schema.optionalKey<Schema.Struct<{
2754
+ readonly base: Schema.optionalKey<Schema.String>;
2755
+ readonly plan: Schema.Struct<{
2756
+ readonly command: Schema.String;
2757
+ readonly prepare: Schema.optionalKey<Schema.String>;
2758
+ readonly workingDirectory: Schema.optionalKey<Schema.String>;
2759
+ readonly warmup: Schema.optionalKey<Schema.Int>;
2760
+ readonly metrics: Schema.$Array<Schema.Struct<{
2761
+ readonly name: Schema.String;
2762
+ readonly direction: Schema.Literals<readonly ["lower", "higher"]>;
2763
+ readonly role: Schema.Literals<readonly ["primary", "guardrail"]>;
2764
+ readonly lowVariance: Schema.optionalKey<Schema.Boolean>;
2765
+ }>>;
2766
+ }>;
2767
+ readonly samples: Schema.Int;
2768
+ readonly calibrate: Schema.Boolean;
2769
+ }>>;
2770
+ /** Revisions to resolve to commits in place of checks. */
2771
+ resolve: Schema.optionalKey<Schema.Struct<{
2772
+ readonly revisions: Schema.$Array<Schema.String>;
2773
+ }>>;
2985
2774
  }>, Schema.Struct<{
2986
- readonly settled: Schema.Boolean;
2987
- readonly outputSubmitted: Schema.optionalKey<Schema.Boolean>;
2988
- readonly outputMerged: Schema.optionalKey<Schema.Boolean>;
2989
- readonly questionOpen: Schema.optionalKey<Schema.Boolean>;
2990
- readonly revokedSecrets: Schema.optionalKey<Schema.$Array<Schema.String>>;
2991
- }>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"IntegrationBranch", Schema.Struct<{
2775
+ readonly verificationId: Schema.String;
2776
+ }>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"AdmitChild", Schema.Struct<{
2992
2777
  lease: Schema.Struct<{
2993
2778
  readonly workUnitId: Schema.String;
2994
2779
  readonly leaseOwnerId: Schema.String;
@@ -2998,27 +2783,15 @@ export declare const RunnerRpcs: RpcGroup.RpcGroup<Rpc.Rpc<"AdmitChild", Schema.
2998
2783
  readonly fencingToken: Schema.String;
2999
2784
  readonly capacitySlot: Schema.String;
3000
2785
  }>;
3001
- repoBindingId: Schema.optionalKey<Schema.String>;
2786
+ step: Schema.String;
2787
+ loop: Schema.String;
2788
+ input: Schema.Codec<Schema.Json, Schema.Json, never, never>;
2789
+ /** Constraints the Child Run's Intent starts with besides its parent's. */
2790
+ constraints: Schema.optional<Schema.$Array<Schema.String>>;
2791
+ deferredName: Schema.String;
3002
2792
  }>, Schema.Struct<{
3003
- readonly repoBindingId: Schema.String;
3004
- readonly branch: Schema.String;
3005
- readonly revision: Schema.String;
3006
- }>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"KnownEvidence", Schema.Struct<{
3007
- lease: Schema.Struct<{
3008
- readonly workUnitId: Schema.String;
3009
- readonly leaseOwnerId: Schema.String;
3010
- readonly runnerReplicaId: Schema.String;
3011
- readonly leaseId: Schema.String;
3012
- readonly attempt: Schema.Int;
3013
- readonly fencingToken: Schema.String;
3014
- readonly capacitySlot: Schema.String;
3015
- }>;
3016
- trees: Schema.$Array<Schema.String>;
3017
- }>, Schema.$Array<Schema.Struct<{
3018
- readonly tree: Schema.String;
3019
- readonly name: Schema.String;
3020
- readonly command: Schema.String;
3021
- }>>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"MergeChangeRequest", Schema.Struct<{
2793
+ readonly runId: Schema.String;
2794
+ }>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"StoreArtifact", Schema.Struct<{
3022
2795
  lease: Schema.Struct<{
3023
2796
  readonly workUnitId: Schema.String;
3024
2797
  readonly leaseOwnerId: Schema.String;
@@ -3029,17 +2802,14 @@ export declare const RunnerRpcs: RpcGroup.RpcGroup<Rpc.Rpc<"AdmitChild", Schema.
3029
2802
  readonly capacitySlot: Schema.String;
3030
2803
  }>;
3031
2804
  step: Schema.String;
3032
- changeRequestId: Schema.String;
3033
- head: Schema.optionalKey<Schema.String>;
3034
- }>, Schema.Union<readonly [Schema.Struct<{
3035
- readonly status: Schema.Literal<"merged">;
3036
- readonly revision: Schema.String;
3037
- }>, Schema.Struct<{
3038
- readonly status: Schema.Literal<"conflict">;
2805
+ kind: Schema.String;
2806
+ title: Schema.String;
2807
+ text: Schema.String;
2808
+ data: Schema.optional<Schema.Codec<Schema.Json, Schema.Json, never, never>>;
2809
+ fileIds: Schema.optional<Schema.$Array<Schema.String>>;
3039
2810
  }>, Schema.Struct<{
3040
- readonly status: Schema.Literal<"moved">;
3041
- readonly head: Schema.String;
3042
- }>]>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"OpenChangeRequests", Schema.Struct<{
2811
+ readonly artifactId: Schema.String;
2812
+ }>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"AlertTask", Schema.Struct<{
3043
2813
  lease: Schema.Struct<{
3044
2814
  readonly workUnitId: Schema.String;
3045
2815
  readonly leaseOwnerId: Schema.String;
@@ -3050,18 +2820,20 @@ export declare const RunnerRpcs: RpcGroup.RpcGroup<Rpc.Rpc<"AdmitChild", Schema.
3050
2820
  readonly capacitySlot: Schema.String;
3051
2821
  }>;
3052
2822
  step: Schema.String;
3053
- authors: Schema.NonEmptyArray<Schema.String>;
2823
+ fingerprint: Schema.String;
2824
+ title: Schema.String;
2825
+ windowHours: Schema.Int;
2826
+ resolved: Schema.optionalKey<Schema.Boolean>;
2827
+ priority: Schema.optionalKey<Schema.Literals<readonly ["urgent", "high", "medium", "low"]>>;
3054
2828
  }>, Schema.Struct<{
3055
- readonly changeRequests: Schema.$Array<Schema.Struct<{
3056
- readonly number: Schema.String;
3057
- readonly title: Schema.String;
3058
- readonly body: Schema.String;
3059
- readonly url: Schema.String;
3060
- readonly author: Schema.String;
3061
- readonly sourceBranch: Schema.String;
3062
- readonly head: Schema.String;
2829
+ readonly taskId: Schema.optionalKey<Schema.String>;
2830
+ readonly created: Schema.Boolean;
2831
+ readonly resolved: Schema.optionalKey<Schema.Boolean>;
2832
+ readonly joined: Schema.optionalKey<Schema.Struct<{
2833
+ readonly kind: Schema.Literals<readonly ["run", "recent"]>;
2834
+ readonly runId: Schema.String;
3063
2835
  }>>;
3064
- }>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"OwnChangeRequests", Schema.Struct<{
2836
+ }>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"ReadTranscripts", Schema.Struct<{
3065
2837
  lease: Schema.Struct<{
3066
2838
  readonly workUnitId: Schema.String;
3067
2839
  readonly leaseOwnerId: Schema.String;
@@ -3072,52 +2844,23 @@ export declare const RunnerRpcs: RpcGroup.RpcGroup<Rpc.Rpc<"AdmitChild", Schema.
3072
2844
  readonly capacitySlot: Schema.String;
3073
2845
  }>;
3074
2846
  step: Schema.String;
2847
+ days: Schema.Int;
3075
2848
  }>, Schema.Struct<{
3076
- readonly changeRequests: Schema.$Array<Schema.Struct<{
3077
- readonly id: Schema.String;
3078
- readonly number: Schema.String;
3079
- readonly url: Schema.String;
3080
- readonly title: Schema.String;
3081
- readonly sourceBranch: Schema.String;
3082
- readonly body: Schema.String;
2849
+ readonly runs: Schema.$Array<Schema.Struct<{
2850
+ readonly runId: Schema.String;
2851
+ readonly loopId: Schema.String;
2852
+ readonly status: Schema.optionalKey<Schema.Literals<readonly ["completed", "failed", "canceled", "expired"]>>;
2853
+ readonly teamId: Schema.optionalKey<Schema.String>;
2854
+ readonly failure: Schema.optionalKey<Schema.String>;
2855
+ readonly retried: Schema.optionalKey<Schema.Boolean>;
2856
+ readonly entries: Schema.$Array<Schema.Struct<{
2857
+ readonly stepAttemptId: Schema.String;
2858
+ readonly sequence: Schema.Int;
2859
+ readonly kind: Schema.String;
2860
+ readonly text: Schema.String;
2861
+ }>>;
3083
2862
  }>>;
3084
- }>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"PerformHostEffect", Schema.Struct<{
3085
- lease: Schema.Struct<{
3086
- readonly workUnitId: Schema.String;
3087
- readonly leaseOwnerId: Schema.String;
3088
- readonly runnerReplicaId: Schema.String;
3089
- readonly leaseId: Schema.String;
3090
- readonly attempt: Schema.Int;
3091
- readonly fencingToken: Schema.String;
3092
- readonly capacitySlot: Schema.String;
3093
- }>;
3094
- step: Schema.String;
3095
- effect: Schema.Union<readonly [Schema.Struct<{
3096
- readonly kind: Schema.Literal<"post_comment">;
3097
- readonly changeRequestId: Schema.String;
3098
- readonly body: Schema.String;
3099
- readonly threadId: Schema.optionalKey<Schema.String>;
3100
- readonly summary: Schema.optionalKey<Schema.String>;
3101
- readonly anchors: Schema.optionalKey<Schema.$Array<Schema.Struct<{
3102
- readonly file: Schema.String;
3103
- readonly line: Schema.Int;
3104
- readonly body: Schema.String;
3105
- }>>>;
3106
- }>, Schema.Struct<{
3107
- readonly kind: Schema.Literal<"change_request">;
3108
- readonly title: Schema.String;
3109
- readonly body: Schema.String;
3110
- readonly integration: Schema.optionalKey<Schema.String>;
3111
- }>, Schema.Struct<{
3112
- readonly kind: Schema.Literal<"write_back">;
3113
- readonly milestone: Schema.optionalKey<Schema.Literals<readonly ["started", "change_request_opened", "merged", "failed"]>>;
3114
- readonly changeRequestUrl: Schema.optionalKey<Schema.String>;
3115
- }>]>;
3116
- }>, Schema.UndefinedOr<Schema.Struct<{
3117
- readonly id: Schema.String;
3118
- readonly number: Schema.String;
3119
- readonly url: Schema.String;
3120
- }>>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"PipelineStatus", Schema.Struct<{
2863
+ }>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"PipelineStatus", Schema.Struct<{
3121
2864
  lease: Schema.Struct<{
3122
2865
  readonly workUnitId: Schema.String;
3123
2866
  readonly leaseOwnerId: Schema.String;
@@ -3156,7 +2899,68 @@ export declare const RunnerRpcs: RpcGroup.RpcGroup<Rpc.Rpc<"AdmitChild", Schema.
3156
2899
  readonly logTail: Schema.optionalKey<Schema.String>;
3157
2900
  }>>;
3158
2901
  }>>;
3159
- }>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"ProgramSecrets", Schema.Struct<{
2902
+ }>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"ReportPipeline", Schema.Struct<{
2903
+ lease: Schema.Struct<{
2904
+ readonly workUnitId: Schema.String;
2905
+ readonly leaseOwnerId: Schema.String;
2906
+ readonly runnerReplicaId: Schema.String;
2907
+ readonly leaseId: Schema.String;
2908
+ readonly attempt: Schema.Int;
2909
+ readonly fencingToken: Schema.String;
2910
+ readonly capacitySlot: Schema.String;
2911
+ }>;
2912
+ step: Schema.String;
2913
+ changeRequestId: Schema.String;
2914
+ verification: Schema.String;
2915
+ }>, Schema.Struct<{
2916
+ readonly head: Schema.String;
2917
+ readonly status: Schema.Literals<readonly ["success", "failed"]>;
2918
+ }>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"ReviewThreads", Schema.Struct<{
2919
+ lease: Schema.Struct<{
2920
+ readonly workUnitId: Schema.String;
2921
+ readonly leaseOwnerId: Schema.String;
2922
+ readonly runnerReplicaId: Schema.String;
2923
+ readonly leaseId: Schema.String;
2924
+ readonly attempt: Schema.Int;
2925
+ readonly fencingToken: Schema.String;
2926
+ readonly capacitySlot: Schema.String;
2927
+ }>;
2928
+ step: Schema.String;
2929
+ changeRequestId: Schema.String;
2930
+ }>, Schema.Struct<{
2931
+ readonly threads: Schema.$Array<Schema.Struct<{
2932
+ readonly id: Schema.String;
2933
+ readonly path: Schema.optionalKey<Schema.String>;
2934
+ readonly line: Schema.optionalKey<Schema.Int>;
2935
+ readonly outdated: Schema.optionalKey<Schema.Boolean>;
2936
+ readonly comments: Schema.$Array<Schema.Struct<{
2937
+ readonly author: Schema.optionalKey<Schema.String>;
2938
+ readonly body: Schema.String;
2939
+ }>>;
2940
+ }>>;
2941
+ }>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"OpenChangeRequests", Schema.Struct<{
2942
+ lease: Schema.Struct<{
2943
+ readonly workUnitId: Schema.String;
2944
+ readonly leaseOwnerId: Schema.String;
2945
+ readonly runnerReplicaId: Schema.String;
2946
+ readonly leaseId: Schema.String;
2947
+ readonly attempt: Schema.Int;
2948
+ readonly fencingToken: Schema.String;
2949
+ readonly capacitySlot: Schema.String;
2950
+ }>;
2951
+ step: Schema.String;
2952
+ authors: Schema.NonEmptyArray<Schema.String>;
2953
+ }>, Schema.Struct<{
2954
+ readonly changeRequests: Schema.$Array<Schema.Struct<{
2955
+ readonly number: Schema.String;
2956
+ readonly title: Schema.String;
2957
+ readonly body: Schema.String;
2958
+ readonly url: Schema.String;
2959
+ readonly author: Schema.String;
2960
+ readonly sourceBranch: Schema.String;
2961
+ readonly head: Schema.String;
2962
+ }>>;
2963
+ }>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"OwnChangeRequests", Schema.Struct<{
3160
2964
  lease: Schema.Struct<{
3161
2965
  readonly workUnitId: Schema.String;
3162
2966
  readonly leaseOwnerId: Schema.String;
@@ -3166,7 +2970,17 @@ export declare const RunnerRpcs: RpcGroup.RpcGroup<Rpc.Rpc<"AdmitChild", Schema.
3166
2970
  readonly fencingToken: Schema.String;
3167
2971
  readonly capacitySlot: Schema.String;
3168
2972
  }>;
3169
- }>, Schema.$Record<Schema.String, Schema.String>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"Propose", Schema.Struct<{
2973
+ step: Schema.String;
2974
+ }>, Schema.Struct<{
2975
+ readonly changeRequests: Schema.$Array<Schema.Struct<{
2976
+ readonly id: Schema.String;
2977
+ readonly number: Schema.String;
2978
+ readonly url: Schema.String;
2979
+ readonly title: Schema.String;
2980
+ readonly sourceBranch: Schema.String;
2981
+ readonly body: Schema.String;
2982
+ }>>;
2983
+ }>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"Propose", Schema.Struct<{
3170
2984
  lease: Schema.Struct<{
3171
2985
  readonly workUnitId: Schema.String;
3172
2986
  readonly leaseOwnerId: Schema.String;
@@ -3202,7 +3016,7 @@ export declare const RunnerRpcs: RpcGroup.RpcGroup<Rpc.Rpc<"AdmitChild", Schema.
3202
3016
  readonly kind: Schema.Literals<readonly ["memory", "task"]>;
3203
3017
  readonly id: Schema.String;
3204
3018
  readonly matched: Schema.optionalKey<Schema.Boolean>;
3205
- }>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"PublishRelease", Schema.Struct<{
3019
+ }>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"ReadProject", Schema.Struct<{
3206
3020
  lease: Schema.Struct<{
3207
3021
  readonly workUnitId: Schema.String;
3208
3022
  readonly leaseOwnerId: Schema.String;
@@ -3213,59 +3027,7 @@ export declare const RunnerRpcs: RpcGroup.RpcGroup<Rpc.Rpc<"AdmitChild", Schema.
3213
3027
  readonly capacitySlot: Schema.String;
3214
3028
  }>;
3215
3029
  step: Schema.String;
3216
- tag: Schema.String;
3217
- revision: Schema.optionalKey<Schema.String>;
3218
- title: Schema.String;
3219
- notes: Schema.String;
3220
- }>, Schema.Struct<{
3221
- readonly tag: Schema.String;
3222
- readonly revision: Schema.String;
3223
- readonly url: Schema.String;
3224
- }>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"PutQuestion", Schema.Struct<{
3225
- lease: Schema.Struct<{
3226
- readonly workUnitId: Schema.String;
3227
- readonly leaseOwnerId: Schema.String;
3228
- readonly runnerReplicaId: Schema.String;
3229
- readonly leaseId: Schema.String;
3230
- readonly attempt: Schema.Int;
3231
- readonly fencingToken: Schema.String;
3232
- readonly capacitySlot: Schema.String;
3233
- }>;
3234
- step: Schema.String;
3235
- prompt: Schema.String;
3236
- options: Schema.optional<Schema.$Array<Schema.String>>;
3237
- optionDescriptions: Schema.optional<Schema.$Record<Schema.String, Schema.String>>;
3238
- recommended: Schema.optional<Schema.String>;
3239
- recommendationReason: Schema.optional<Schema.String>;
3240
- informationOnly: Schema.optional<Schema.Boolean>;
3241
- /** Approving the Question approves this verification for the Run's repository. */
3242
- verification: Schema.optional<Schema.Struct<{
3243
- readonly name: Schema.String;
3244
- readonly command: Schema.String;
3245
- readonly workingDirectory: Schema.optional<Schema.String>;
3246
- }>>;
3247
- /** Taken when the Run is unattended, or when nobody answers within `timeoutMillis`. */
3248
- default: Schema.optional<Schema.String>;
3249
- /** Taken at once when the Run's Team delivers in full auto. */
3250
- auto: Schema.optional<Schema.String>;
3251
- /** Taken at once when the Run's Team delivers in full auto and nobody attends the Run. */
3252
- unattendedAuto: Schema.optional<Schema.String>;
3253
- timeoutMillis: Schema.optional<Schema.Finite>;
3254
- deferredName: Schema.String;
3255
- }>, Schema.Struct<{
3256
- readonly questionId: Schema.String;
3257
- }>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"ReadProject", Schema.Struct<{
3258
- lease: Schema.Struct<{
3259
- readonly workUnitId: Schema.String;
3260
- readonly leaseOwnerId: Schema.String;
3261
- readonly runnerReplicaId: Schema.String;
3262
- readonly leaseId: Schema.String;
3263
- readonly attempt: Schema.Int;
3264
- readonly fencingToken: Schema.String;
3265
- readonly capacitySlot: Schema.String;
3266
- }>;
3267
- step: Schema.String;
3268
- projectId: Schema.String;
3030
+ projectId: Schema.String;
3269
3031
  }>, Schema.Struct<{
3270
3032
  readonly project: Schema.Struct<{
3271
3033
  readonly id: Schema.String;
@@ -3293,7 +3055,7 @@ export declare const RunnerRpcs: RpcGroup.RpcGroup<Rpc.Rpc<"AdmitChild", Schema.
3293
3055
  readonly change: Schema.String;
3294
3056
  readonly at: Schema.String;
3295
3057
  }>>;
3296
- }>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"ReadTranscripts", Schema.Struct<{
3058
+ }>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"DraftUpdate", Schema.Struct<{
3297
3059
  lease: Schema.Struct<{
3298
3060
  readonly workUnitId: Schema.String;
3299
3061
  readonly leaseOwnerId: Schema.String;
@@ -3304,36 +3066,17 @@ export declare const RunnerRpcs: RpcGroup.RpcGroup<Rpc.Rpc<"AdmitChild", Schema.
3304
3066
  readonly capacitySlot: Schema.String;
3305
3067
  }>;
3306
3068
  step: Schema.String;
3307
- days: Schema.Int;
3308
- }>, Schema.Struct<{
3309
- readonly runs: Schema.$Array<Schema.Struct<{
3310
- readonly runId: Schema.String;
3311
- readonly loopId: Schema.String;
3312
- readonly status: Schema.optionalKey<Schema.Literals<readonly ["completed", "failed", "canceled", "expired"]>>;
3313
- readonly teamId: Schema.optionalKey<Schema.String>;
3314
- readonly failure: Schema.optionalKey<Schema.String>;
3315
- readonly retried: Schema.optionalKey<Schema.Boolean>;
3316
- readonly entries: Schema.$Array<Schema.Struct<{
3317
- readonly stepAttemptId: Schema.String;
3318
- readonly sequence: Schema.Int;
3319
- readonly kind: Schema.String;
3320
- readonly text: Schema.String;
3321
- }>>;
3322
- }>>;
3323
- }>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"RecordActivity", Schema.Struct<{
3324
- lease: Schema.Struct<{
3325
- readonly workUnitId: Schema.String;
3326
- readonly leaseOwnerId: Schema.String;
3327
- readonly runnerReplicaId: Schema.String;
3328
- readonly leaseId: Schema.String;
3329
- readonly attempt: Schema.Int;
3330
- readonly fencingToken: Schema.String;
3331
- readonly capacitySlot: Schema.String;
3069
+ projectId: Schema.String;
3070
+ health: Schema.Literals<readonly ["on_track", "at_risk", "off_track"]>;
3071
+ note: Schema.String;
3072
+ writtenFrom: Schema.Struct<{
3073
+ readonly runs: Schema.Int;
3074
+ readonly taskChanges: Schema.Int;
3075
+ readonly since: Schema.optionalKey<Schema.String>;
3332
3076
  }>;
3333
- name: Schema.String;
3334
- attempt: Schema.Int;
3335
- exit: Schema.Codec<Schema.Json, Schema.Json, never, never>;
3336
- }>, Schema.Void, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"RecordNote", Schema.Struct<{
3077
+ }>, Schema.Struct<{
3078
+ readonly id: Schema.String;
3079
+ }>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"IntegrationBranch", Schema.Struct<{
3337
3080
  lease: Schema.Struct<{
3338
3081
  readonly workUnitId: Schema.String;
3339
3082
  readonly leaseOwnerId: Schema.String;
@@ -3343,25 +3086,12 @@ export declare const RunnerRpcs: RpcGroup.RpcGroup<Rpc.Rpc<"AdmitChild", Schema.
3343
3086
  readonly fencingToken: Schema.String;
3344
3087
  readonly capacitySlot: Schema.String;
3345
3088
  }>;
3346
- step: Schema.String;
3347
- text: Schema.String;
3348
- artifactId: Schema.optional<Schema.String>;
3349
- /** A `blocker` records what the Task waits on; a note when left out. */
3350
- kind: Schema.optional<Schema.Literals<readonly ["note", "blocker"]>>;
3351
- }>, Schema.Void, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"Release", Schema.Struct<{
3352
- readonly workUnitId: Schema.String;
3353
- readonly lease: Schema.Struct<{
3354
- readonly leaseOwnerId: Schema.String;
3355
- readonly runnerReplicaId: Schema.String;
3356
- readonly leaseId: Schema.String;
3357
- readonly attempt: Schema.Int;
3358
- readonly fencingToken: Schema.String;
3359
- readonly capacitySlot: Schema.String;
3360
- }>;
3361
- readonly crashed: Schema.optionalKey<Schema.Struct<{
3362
- readonly reason: Schema.String;
3363
- }>>;
3364
- }>, Schema.Void, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"ReportPipeline", Schema.Struct<{
3089
+ repoBindingId: Schema.optionalKey<Schema.String>;
3090
+ }>, Schema.Struct<{
3091
+ readonly repoBindingId: Schema.String;
3092
+ readonly branch: Schema.String;
3093
+ readonly revision: Schema.String;
3094
+ }>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"CloseChangeRequest", Schema.Struct<{
3365
3095
  lease: Schema.Struct<{
3366
3096
  readonly workUnitId: Schema.String;
3367
3097
  readonly leaseOwnerId: Schema.String;
@@ -3372,16 +3102,13 @@ export declare const RunnerRpcs: RpcGroup.RpcGroup<Rpc.Rpc<"AdmitChild", Schema.
3372
3102
  readonly capacitySlot: Schema.String;
3373
3103
  }>;
3374
3104
  step: Schema.String;
3375
- changeRequestId: Schema.String;
3376
- verification: Schema.String;
3105
+ number: Schema.String;
3106
+ head: Schema.String;
3107
+ note: Schema.String;
3377
3108
  }>, Schema.Struct<{
3378
- readonly head: Schema.String;
3379
- readonly status: Schema.Literals<readonly ["success", "failed"]>;
3380
- }>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"ReportSteer", Schema.Struct<{
3381
- workUnitId: Schema.String;
3382
- messageId: Schema.String;
3383
- delivered: Schema.Boolean;
3384
- }>, Schema.Void, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"RerunPipeline", Schema.Struct<{
3109
+ readonly closed: Schema.Boolean;
3110
+ readonly head: Schema.optionalKey<Schema.String>;
3111
+ }>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"RerunPipeline", Schema.Struct<{
3385
3112
  lease: Schema.Struct<{
3386
3113
  readonly workUnitId: Schema.String;
3387
3114
  readonly leaseOwnerId: Schema.String;
@@ -3398,7 +3125,7 @@ export declare const RunnerRpcs: RpcGroup.RpcGroup<Rpc.Rpc<"AdmitChild", Schema.
3398
3125
  }>, Schema.Struct<{
3399
3126
  readonly head: Schema.String;
3400
3127
  readonly pipelines: Schema.Int;
3401
- }>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"ResumeCheckpoint", Schema.Struct<{
3128
+ }>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"PublishRelease", Schema.Struct<{
3402
3129
  lease: Schema.Struct<{
3403
3130
  readonly workUnitId: Schema.String;
3404
3131
  readonly leaseOwnerId: Schema.String;
@@ -3408,17 +3135,16 @@ export declare const RunnerRpcs: RpcGroup.RpcGroup<Rpc.Rpc<"AdmitChild", Schema.
3408
3135
  readonly fencingToken: Schema.String;
3409
3136
  readonly capacitySlot: Schema.String;
3410
3137
  }>;
3411
- }>, Schema.UndefinedOr<Schema.Struct<{
3412
- readonly ref: Schema.optionalKey<Schema.String>;
3413
- readonly revision: Schema.optionalKey<Schema.String>;
3414
- readonly session: Schema.optionalKey<Schema.Struct<{
3415
- readonly harness: Schema.String;
3416
- readonly id: Schema.String;
3417
- readonly name: Schema.String;
3418
- readonly url: Schema.String;
3419
- readonly headers: Schema.optionalKey<Schema.$Record<Schema.String, Schema.String>>;
3420
- }>>;
3421
- }>>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"ReviewThreads", Schema.Struct<{
3138
+ step: Schema.String;
3139
+ tag: Schema.String;
3140
+ revision: Schema.optionalKey<Schema.String>;
3141
+ title: Schema.String;
3142
+ notes: Schema.String;
3143
+ }>, Schema.Struct<{
3144
+ readonly tag: Schema.String;
3145
+ readonly revision: Schema.String;
3146
+ readonly url: Schema.String;
3147
+ }>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"CreateRunFile", Schema.Struct<{
3422
3148
  lease: Schema.Struct<{
3423
3149
  readonly workUnitId: Schema.String;
3424
3150
  readonly leaseOwnerId: Schema.String;
@@ -3429,19 +3155,40 @@ export declare const RunnerRpcs: RpcGroup.RpcGroup<Rpc.Rpc<"AdmitChild", Schema.
3429
3155
  readonly capacitySlot: Schema.String;
3430
3156
  }>;
3431
3157
  step: Schema.String;
3432
- changeRequestId: Schema.String;
3158
+ name: Schema.String;
3159
+ caption: Schema.optional<Schema.String>;
3160
+ contentType: Schema.String;
3161
+ byteSize: Schema.Int;
3162
+ sha256: Schema.String;
3433
3163
  }>, Schema.Struct<{
3434
- readonly threads: Schema.$Array<Schema.Struct<{
3164
+ readonly file: Schema.Struct<{
3435
3165
  readonly id: Schema.String;
3436
- readonly path: Schema.optionalKey<Schema.String>;
3437
- readonly line: Schema.optionalKey<Schema.Int>;
3438
- readonly outdated: Schema.optionalKey<Schema.Boolean>;
3439
- readonly comments: Schema.$Array<Schema.Struct<{
3440
- readonly author: Schema.optionalKey<Schema.String>;
3441
- readonly body: Schema.String;
3166
+ readonly runId: Schema.String;
3167
+ readonly step: Schema.String;
3168
+ readonly name: Schema.String;
3169
+ readonly caption: Schema.optionalKey<Schema.String>;
3170
+ readonly contentType: Schema.String;
3171
+ readonly kind: Schema.Literals<readonly ["image", "video", "html", "text", "other"]>;
3172
+ readonly byteSize: Schema.Int;
3173
+ readonly sha256: Schema.String;
3174
+ readonly status: Schema.Literals<readonly ["uploading", "available", "rejected", "refused", "removing", "removed", "expired"]>;
3175
+ }>;
3176
+ readonly upload: Schema.optional<Schema.Union<readonly [Schema.Struct<{
3177
+ readonly url: Schema.String;
3178
+ readonly headers: Schema.optionalKey<Schema.$Record<Schema.String, Schema.String>>;
3179
+ readonly expiresAt: Schema.String;
3180
+ readonly kind: Schema.Literal<"single">;
3181
+ }>, Schema.Struct<{
3182
+ readonly kind: Schema.Literal<"multipart">;
3183
+ readonly partSize: Schema.Int;
3184
+ readonly parts: Schema.$Array<Schema.Struct<{
3185
+ readonly url: Schema.String;
3186
+ readonly headers: Schema.optionalKey<Schema.$Record<Schema.String, Schema.String>>;
3187
+ readonly expiresAt: Schema.String;
3188
+ readonly partNumber: Schema.Int;
3442
3189
  }>>;
3443
- }>>;
3444
- }>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"RunFileParts", Schema.Struct<{
3190
+ }>]>>;
3191
+ }>, Schema.Union<readonly [typeof RunnerRpcError, typeof RunFileRefused]>, typeof RunnerAuthentication, never> | Rpc.Rpc<"RunFileParts", Schema.Struct<{
3445
3192
  lease: Schema.Struct<{
3446
3193
  readonly workUnitId: Schema.String;
3447
3194
  readonly leaseOwnerId: Schema.String;
@@ -3460,27 +3207,7 @@ export declare const RunnerRpcs: RpcGroup.RpcGroup<Rpc.Rpc<"AdmitChild", Schema.
3460
3207
  readonly expiresAt: Schema.String;
3461
3208
  readonly partNumber: Schema.Int;
3462
3209
  }>>;
3463
- }>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"SaveCheckpoint", Schema.Struct<{
3464
- lease: Schema.Struct<{
3465
- readonly workUnitId: Schema.String;
3466
- readonly leaseOwnerId: Schema.String;
3467
- readonly runnerReplicaId: Schema.String;
3468
- readonly leaseId: Schema.String;
3469
- readonly attempt: Schema.Int;
3470
- readonly fencingToken: Schema.String;
3471
- readonly capacitySlot: Schema.String;
3472
- }>;
3473
- checkpoint: Schema.Struct<{
3474
- readonly ref: Schema.optionalKey<Schema.String>;
3475
- readonly revision: Schema.optionalKey<Schema.String>;
3476
- readonly session: Schema.optionalKey<Schema.Struct<{
3477
- readonly harness: Schema.String;
3478
- readonly id: Schema.String;
3479
- readonly name: Schema.String;
3480
- readonly fileId: Schema.String;
3481
- }>>;
3482
- }>;
3483
- }>, Schema.Void, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"ScheduleClock", Schema.Struct<{
3210
+ }>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"ResumeCheckpoint", Schema.Struct<{
3484
3211
  lease: Schema.Struct<{
3485
3212
  readonly workUnitId: Schema.String;
3486
3213
  readonly leaseOwnerId: Schema.String;
@@ -3490,45 +3217,22 @@ export declare const RunnerRpcs: RpcGroup.RpcGroup<Rpc.Rpc<"AdmitChild", Schema.
3490
3217
  readonly fencingToken: Schema.String;
3491
3218
  readonly capacitySlot: Schema.String;
3492
3219
  }>;
3493
- name: Schema.String;
3494
- deferredName: Schema.String;
3495
- durationMillis: Schema.Int;
3496
- }>, Schema.Void, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"SettledCheckpoints", Schema.Void, Schema.$Array<Schema.Struct<{
3497
- readonly stepAttemptId: Schema.String;
3220
+ }>, Schema.UndefinedOr<Schema.Struct<{
3498
3221
  readonly ref: Schema.optionalKey<Schema.String>;
3499
- readonly repoBinding: Schema.optionalKey<Schema.Struct<{
3222
+ readonly revision: Schema.optionalKey<Schema.String>;
3223
+ readonly session: Schema.optionalKey<Schema.Struct<{
3224
+ readonly harness: Schema.String;
3500
3225
  readonly id: Schema.String;
3501
- readonly provider: Schema.Literals<readonly ["github", "gitlab", "forgejo", "gitea", "gitee", "bitbucket", "azure-devops", "generic_git"]>;
3502
- readonly host: Schema.String;
3503
- readonly owner: Schema.String;
3504
3226
  readonly name: Schema.String;
3505
- readonly repositoryUrl: Schema.optionalKey<Schema.String>;
3506
- readonly pathPrefix: Schema.optionalKey<Schema.String>;
3507
- readonly defaultTargetBranch: Schema.String;
3508
- readonly expectedBranch: Schema.optionalKey<Schema.String>;
3509
- readonly expectedCommitSha: Schema.optionalKey<Schema.String>;
3227
+ readonly url: Schema.String;
3228
+ readonly headers: Schema.optionalKey<Schema.$Record<Schema.String, Schema.String>>;
3510
3229
  }>>;
3511
- }>>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"SettledRuns", Schema.Struct<{
3512
- runIds: Schema.$Array<Schema.String>;
3513
- }>, Schema.$Array<Schema.String>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"Signals", Schema.Struct<{
3514
- runnerReplicaId: Schema.String;
3515
- }>, import("effect/rpc/RpcSchema").Stream<Schema.Union<readonly [Schema.TaggedStruct<"WorkAvailable", {}>, Schema.TaggedStruct<"LeaseRevoked", {
3516
- readonly workUnitId: Schema.String;
3517
- }>, Schema.TaggedStruct<"Settled", {
3518
- readonly workUnitId: Schema.String;
3519
- }>, Schema.TaggedStruct<"Canceled", {
3520
- readonly workUnitId: Schema.String;
3521
- }>, Schema.TaggedStruct<"RunSettled", {
3522
- readonly runId: Schema.String;
3523
- }>, Schema.TaggedStruct<"Steer", {
3524
- readonly workUnitId: Schema.String;
3525
- readonly messageId: Schema.String;
3526
- readonly text: Schema.String;
3527
- }>, Schema.TaggedStruct<"SessionUpdated", {
3528
- readonly workUnitId: Schema.String;
3529
- }>, Schema.TaggedStruct<"UpdateAvailable", {
3530
- readonly version: Schema.String;
3531
- }>]>, typeof RunnerRpcError>, Schema.Never, typeof RunnerAuthentication, never> | Rpc.Rpc<"StartAgentStep", Schema.Struct<{
3230
+ }>>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"GitCredential", Schema.Struct<{
3231
+ repoBindingId: Schema.String;
3232
+ }>, Schema.UndefinedOr<Schema.Struct<{
3233
+ readonly username: Schema.String;
3234
+ readonly password: Schema.String;
3235
+ }>>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"PerformHostEffect", Schema.Struct<{
3532
3236
  lease: Schema.Struct<{
3533
3237
  readonly workUnitId: Schema.String;
3534
3238
  readonly leaseOwnerId: Schema.String;
@@ -3539,23 +3243,122 @@ export declare const RunnerRpcs: RpcGroup.RpcGroup<Rpc.Rpc<"AdmitChild", Schema.
3539
3243
  readonly capacitySlot: Schema.String;
3540
3244
  }>;
3541
3245
  step: Schema.String;
3542
- deferredName: Schema.String;
3543
- role: Schema.String;
3544
- agentId: Schema.String;
3545
- prompt: Schema.String;
3546
- /** The skill the Step runs. */
3547
- skill: Schema.optionalKey<Schema.String>;
3548
- outputSchema: Schema.Codec<Schema.Json, Schema.Json, never, never>;
3549
- secrets: Schema.optionalKey<Schema.$Array<Schema.String>>;
3550
- timeoutMillis: Schema.optionalKey<Schema.Int>;
3551
- /** The branch whose head the Runner merges into the checkout before the agent starts. */
3552
- mergeTarget: Schema.optionalKey<Schema.String>;
3553
- }>, Schema.Struct<{
3554
- readonly stepAttemptId: Schema.String;
3555
- }>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"StartVerification", Schema.Struct<{
3556
- lease: Schema.Struct<{
3557
- readonly workUnitId: Schema.String;
3558
- readonly leaseOwnerId: Schema.String;
3246
+ effect: Schema.Union<readonly [Schema.Struct<{
3247
+ readonly kind: Schema.Literal<"post_comment">;
3248
+ readonly changeRequestId: Schema.String;
3249
+ readonly body: Schema.String;
3250
+ readonly threadId: Schema.optionalKey<Schema.String>;
3251
+ readonly summary: Schema.optionalKey<Schema.String>;
3252
+ readonly anchors: Schema.optionalKey<Schema.$Array<Schema.Struct<{
3253
+ readonly file: Schema.String;
3254
+ readonly line: Schema.Int;
3255
+ readonly body: Schema.String;
3256
+ }>>>;
3257
+ }>, Schema.Struct<{
3258
+ readonly kind: Schema.Literal<"change_request">;
3259
+ readonly title: Schema.String;
3260
+ readonly body: Schema.String;
3261
+ readonly integration: Schema.optionalKey<Schema.String>;
3262
+ }>, Schema.Struct<{
3263
+ readonly kind: Schema.Literal<"write_back">;
3264
+ readonly milestone: Schema.optionalKey<Schema.Literals<readonly ["started", "change_request_opened", "merged", "failed"]>>;
3265
+ readonly changeRequestUrl: Schema.optionalKey<Schema.String>;
3266
+ }>]>;
3267
+ }>, Schema.UndefinedOr<Schema.Struct<{
3268
+ readonly id: Schema.String;
3269
+ readonly number: Schema.String;
3270
+ readonly url: Schema.String;
3271
+ }>>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"ApproveChangeRequest", Schema.Struct<{
3272
+ lease: Schema.Struct<{
3273
+ readonly workUnitId: Schema.String;
3274
+ readonly leaseOwnerId: Schema.String;
3275
+ readonly runnerReplicaId: Schema.String;
3276
+ readonly leaseId: Schema.String;
3277
+ readonly attempt: Schema.Int;
3278
+ readonly fencingToken: Schema.String;
3279
+ readonly capacitySlot: Schema.String;
3280
+ }>;
3281
+ step: Schema.String;
3282
+ changeRequestId: Schema.String;
3283
+ head: Schema.String;
3284
+ summary: Schema.String;
3285
+ review: Schema.optionalKey<Schema.String>;
3286
+ carries: Schema.optionalKey<Schema.String>;
3287
+ }>, Schema.Union<readonly [Schema.Struct<{
3288
+ readonly approved: Schema.Literal<true>;
3289
+ readonly reviewId: Schema.String;
3290
+ }>, Schema.Struct<{
3291
+ readonly approved: Schema.Literal<false>;
3292
+ readonly reason: Schema.String;
3293
+ }>]>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"MergeChangeRequest", Schema.Struct<{
3294
+ lease: Schema.Struct<{
3295
+ readonly workUnitId: Schema.String;
3296
+ readonly leaseOwnerId: Schema.String;
3297
+ readonly runnerReplicaId: Schema.String;
3298
+ readonly leaseId: Schema.String;
3299
+ readonly attempt: Schema.Int;
3300
+ readonly fencingToken: Schema.String;
3301
+ readonly capacitySlot: Schema.String;
3302
+ }>;
3303
+ step: Schema.String;
3304
+ changeRequestId: Schema.String;
3305
+ head: Schema.optionalKey<Schema.String>;
3306
+ }>, Schema.Union<readonly [Schema.Struct<{
3307
+ readonly status: Schema.Literal<"merged">;
3308
+ readonly revision: Schema.String;
3309
+ }>, Schema.Struct<{
3310
+ readonly status: Schema.Literal<"conflict">;
3311
+ }>, Schema.Struct<{
3312
+ readonly status: Schema.Literal<"moved">;
3313
+ readonly head: Schema.String;
3314
+ }>]>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"AppendTranscript", Schema.Struct<{
3315
+ workUnitId: Schema.String;
3316
+ entries: Schema.$Array<Schema.Struct<{
3317
+ readonly sequence: Schema.Int;
3318
+ readonly event: Schema.Union<readonly [Schema.Struct<{
3319
+ readonly kind: Schema.Literal<"message">;
3320
+ readonly role: Schema.Literals<readonly ["assistant", "user"]>;
3321
+ readonly text: Schema.String;
3322
+ }>, Schema.Struct<{
3323
+ readonly kind: Schema.Literal<"tool_call">;
3324
+ readonly callId: Schema.String;
3325
+ readonly name: Schema.String;
3326
+ readonly arguments: Schema.Codec<Schema.Json, Schema.Json, never, never>;
3327
+ }>, Schema.Struct<{
3328
+ readonly kind: Schema.Literal<"tool_result">;
3329
+ readonly callId: Schema.String;
3330
+ readonly output: Schema.String;
3331
+ readonly isError: Schema.optionalKey<Schema.Boolean>;
3332
+ }>, Schema.Struct<{
3333
+ readonly kind: Schema.Literal<"file">;
3334
+ readonly path: Schema.String;
3335
+ readonly change: Schema.Literals<readonly ["read", "changed"]>;
3336
+ }>, Schema.Struct<{
3337
+ readonly kind: Schema.Literal<"question">;
3338
+ readonly text: Schema.String;
3339
+ }>, Schema.Struct<{
3340
+ readonly kind: Schema.Literal<"answer">;
3341
+ readonly callId: Schema.optionalKey<Schema.String>;
3342
+ readonly questionId: Schema.optionalKey<Schema.String>;
3343
+ readonly text: Schema.String;
3344
+ }>, Schema.Struct<{
3345
+ readonly kind: Schema.Literal<"steer">;
3346
+ readonly messageId: Schema.String;
3347
+ readonly text: Schema.String;
3348
+ }>, Schema.Struct<{
3349
+ readonly kind: Schema.Literal<"secret_refused">;
3350
+ readonly reference: Schema.optionalKey<Schema.String>;
3351
+ readonly host: Schema.String;
3352
+ readonly reason: Schema.String;
3353
+ }>, Schema.Struct<{
3354
+ readonly kind: Schema.Literal<"lifecycle">;
3355
+ readonly state: Schema.Literals<readonly ["started", "resumed", "parked", "finished", "failed", "canceled"]>;
3356
+ }>]>;
3357
+ }>>;
3358
+ }>, Schema.Void, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"AwaitEvent", Schema.Struct<{
3359
+ lease: Schema.Struct<{
3360
+ readonly workUnitId: Schema.String;
3361
+ readonly leaseOwnerId: Schema.String;
3559
3362
  readonly runnerReplicaId: Schema.String;
3560
3363
  readonly leaseId: Schema.String;
3561
3364
  readonly attempt: Schema.Int;
@@ -3564,43 +3367,193 @@ export declare const RunnerRpcs: RpcGroup.RpcGroup<Rpc.Rpc<"AdmitChild", Schema.
3564
3367
  }>;
3565
3368
  step: Schema.String;
3566
3369
  deferredName: Schema.String;
3567
- /** The Run's head when left out. */
3568
- revision: Schema.optionalKey<Schema.String>;
3569
- checks: Schema.optional<Schema.$Array<Schema.String>>;
3570
- /** Run, labelled as suggested, when the repository has no approved checks. */
3571
- suggested: Schema.optionalKey<Schema.$Array<Schema.Struct<{
3572
- readonly name: Schema.String;
3573
- readonly command: Schema.String;
3574
- readonly workingDirectory: Schema.optionalKey<Schema.String>;
3575
- readonly suggested: Schema.optionalKey<Schema.Boolean>;
3370
+ event: Schema.String;
3371
+ /** Event payload paths and the value, or any of the values, each must hold. */
3372
+ filter: Schema.optional<Schema.$Record<Schema.String, Schema.Union<readonly [Schema.Union<readonly [Schema.String, Schema.Finite, Schema.Boolean, Schema.Null]>, Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Finite, Schema.Boolean, Schema.Null]>>]>>>;
3373
+ timeoutMillis: Schema.Int;
3374
+ /** An ISO time: a state Event received before it never settles the wait, as a newer read superseded it. */
3375
+ since: Schema.optionalKey<Schema.String>;
3376
+ /** Other Events that settle the wait too, each with its own filter and `since`. */
3377
+ or: Schema.optionalKey<Schema.$Array<Schema.Struct<{
3378
+ readonly event: Schema.String;
3379
+ readonly filter: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Union<readonly [Schema.Union<readonly [Schema.String, Schema.Finite, Schema.Boolean, Schema.Null]>, Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Finite, Schema.Boolean, Schema.Null]>>]>>>;
3380
+ readonly since: Schema.optionalKey<Schema.String>;
3576
3381
  }>>>;
3577
- /** Runs a check again whose evidence at the tree failed, rather than reusing that failure; passed evidence is still reused. */
3578
- rerunFailed: Schema.optionalKey<Schema.Boolean>;
3579
- /** A benchmark against `base` (the Run's base branch head when left out) in place of checks. */
3580
- measure: Schema.optionalKey<Schema.Struct<{
3581
- readonly base: Schema.optionalKey<Schema.String>;
3582
- readonly plan: Schema.Struct<{
3583
- readonly command: Schema.String;
3584
- readonly prepare: Schema.optionalKey<Schema.String>;
3585
- readonly workingDirectory: Schema.optionalKey<Schema.String>;
3586
- readonly warmup: Schema.optionalKey<Schema.Int>;
3587
- readonly metrics: Schema.$Array<Schema.Struct<{
3382
+ }>, Schema.Void, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"ClaimResource", Schema.Struct<{
3383
+ lease: Schema.Struct<{
3384
+ readonly workUnitId: Schema.String;
3385
+ readonly leaseOwnerId: Schema.String;
3386
+ readonly runnerReplicaId: Schema.String;
3387
+ readonly leaseId: Schema.String;
3388
+ readonly attempt: Schema.Int;
3389
+ readonly fencingToken: Schema.String;
3390
+ readonly capacitySlot: Schema.String;
3391
+ }>;
3392
+ step: Schema.String;
3393
+ deferredName: Schema.String;
3394
+ resource: Schema.String;
3395
+ action: Schema.Literals<readonly ["claim", "take_over", "let_go"]>;
3396
+ }>, Schema.Void, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"Complete", Schema.Struct<{
3397
+ readonly workUnitId: Schema.String;
3398
+ readonly lease: Schema.Struct<{
3399
+ readonly leaseOwnerId: Schema.String;
3400
+ readonly runnerReplicaId: Schema.String;
3401
+ readonly leaseId: Schema.String;
3402
+ readonly attempt: Schema.Int;
3403
+ readonly fencingToken: Schema.String;
3404
+ readonly capacitySlot: Schema.String;
3405
+ }>;
3406
+ readonly idempotencyKey: Schema.String;
3407
+ readonly outcome: Schema.Struct<{
3408
+ readonly status: Schema.Union<readonly [Schema.Literal<"completed">, Schema.Literal<"failed">, Schema.Literal<"blocked">, Schema.Literal<"canceled">]>;
3409
+ readonly result: Schema.optionalKey<Schema.Struct<{
3410
+ readonly stepKey: Schema.String;
3411
+ readonly outputSchemaRef: Schema.Struct<{
3412
+ readonly kind: Schema.Literal<"typebox_ref">;
3588
3413
  readonly name: Schema.String;
3589
- readonly direction: Schema.Literals<readonly ["lower", "higher"]>;
3590
- readonly role: Schema.Literals<readonly ["primary", "guardrail"]>;
3591
- readonly lowVariance: Schema.optionalKey<Schema.Boolean>;
3414
+ readonly version: Schema.optionalKey<Schema.String>;
3415
+ readonly sha256: Schema.optionalKey<Schema.String>;
3416
+ }>;
3417
+ readonly summary: Schema.String;
3418
+ readonly data: Schema.$Record<Schema.String, Schema.Codec<import("../../../core/src/index").LoopStepOutputDataValue, import("../../../core/src/index").LoopStepOutputDataValue, never, never>>;
3419
+ readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<import("../../../core/src/index").LoopStepOutputDataValue, import("../../../core/src/index").LoopStepOutputDataValue, never, never>>>;
3420
+ readonly refs: Schema.$Array<Schema.Struct<{
3421
+ readonly kind: Schema.Literals<readonly ["task", "kit", "memory", "decision", "knowledge_record", "context_pack", "step_attempt", "change_request", "change_request_review", "provider_action", "thread_entry", "run", "artifact"]>;
3422
+ readonly id: Schema.optionalKey<Schema.String>;
3423
+ readonly externalId: Schema.optionalKey<Schema.String>;
3424
+ readonly provider: Schema.optionalKey<Schema.String>;
3425
+ readonly title: Schema.optionalKey<Schema.String>;
3592
3426
  }>>;
3593
- }>;
3594
- readonly samples: Schema.Int;
3595
- readonly calibrate: Schema.Boolean;
3596
- }>>;
3597
- /** Revisions to resolve to commits in place of checks. */
3598
- resolve: Schema.optionalKey<Schema.Struct<{
3599
- readonly revisions: Schema.$Array<Schema.String>;
3600
- }>>;
3601
- }>, Schema.Struct<{
3602
- readonly verificationId: Schema.String;
3603
- }>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"StoreArtifact", Schema.Struct<{
3427
+ }>>;
3428
+ readonly revision: Schema.optionalKey<Schema.String>;
3429
+ readonly evidence: Schema.optionalKey<Schema.Struct<{
3430
+ readonly head: Schema.Struct<{
3431
+ readonly revision: Schema.String;
3432
+ readonly tree: Schema.String;
3433
+ readonly checks: Schema.$Array<Schema.Struct<{
3434
+ readonly name: Schema.String;
3435
+ readonly command: Schema.String;
3436
+ readonly status: Schema.Union<readonly [Schema.Literal<"passed">, Schema.Literal<"failed">]>;
3437
+ readonly exitCode: Schema.optionalKey<Schema.Int>;
3438
+ readonly durationMs: Schema.Int;
3439
+ readonly outputTail: Schema.String;
3440
+ readonly fileIds: Schema.optionalKey<Schema.$Array<Schema.String>>;
3441
+ readonly tests: Schema.optionalKey<Schema.Struct<{
3442
+ readonly reports: Schema.Int;
3443
+ readonly passed: Schema.Int;
3444
+ readonly failed: Schema.Int;
3445
+ readonly skipped: Schema.Int;
3446
+ readonly skippedTests: Schema.$Array<Schema.String>;
3447
+ readonly ranDigests: Schema.$Array<Schema.String>;
3448
+ }>>;
3449
+ }>>;
3450
+ }>;
3451
+ readonly baseline: Schema.optionalKey<Schema.Struct<{
3452
+ readonly revision: Schema.String;
3453
+ readonly tree: Schema.String;
3454
+ readonly checks: Schema.$Array<Schema.Struct<{
3455
+ readonly name: Schema.String;
3456
+ readonly command: Schema.String;
3457
+ readonly status: Schema.Union<readonly [Schema.Literal<"passed">, Schema.Literal<"failed">]>;
3458
+ readonly exitCode: Schema.optionalKey<Schema.Int>;
3459
+ readonly durationMs: Schema.Int;
3460
+ readonly outputTail: Schema.String;
3461
+ readonly fileIds: Schema.optionalKey<Schema.$Array<Schema.String>>;
3462
+ readonly tests: Schema.optionalKey<Schema.Struct<{
3463
+ readonly reports: Schema.Int;
3464
+ readonly passed: Schema.Int;
3465
+ readonly failed: Schema.Int;
3466
+ readonly skipped: Schema.Int;
3467
+ readonly skippedTests: Schema.$Array<Schema.String>;
3468
+ readonly ranDigests: Schema.$Array<Schema.String>;
3469
+ }>>;
3470
+ }>>;
3471
+ }>>;
3472
+ readonly measurement: Schema.optionalKey<Schema.Struct<{
3473
+ readonly base: Schema.$Array<Schema.$Record<Schema.String, Schema.Finite>>;
3474
+ readonly head: Schema.$Array<Schema.$Record<Schema.String, Schema.Finite>>;
3475
+ readonly baseAgain: Schema.optionalKey<Schema.$Array<Schema.$Record<Schema.String, Schema.Finite>>>;
3476
+ }>>;
3477
+ readonly resolved: Schema.optionalKey<Schema.Struct<{
3478
+ readonly commits: Schema.$Array<Schema.String>;
3479
+ }>>;
3480
+ }>>;
3481
+ readonly boundary: Schema.optionalKey<Schema.Struct<{
3482
+ readonly kind: Schema.Literal<"change">;
3483
+ readonly changedPaths: Schema.$Array<Schema.String>;
3484
+ readonly omittedPaths: Schema.Int;
3485
+ readonly files: Schema.$Array<Schema.Struct<{
3486
+ readonly path: Schema.String;
3487
+ readonly excerpt: Schema.String;
3488
+ readonly redacted: Schema.Boolean;
3489
+ readonly truncated: Schema.Boolean;
3490
+ }>>;
3491
+ readonly truncated: Schema.Boolean;
3492
+ }>>;
3493
+ readonly catchUp: Schema.optionalKey<Schema.Struct<{
3494
+ readonly from: Schema.String;
3495
+ readonly head: Schema.String;
3496
+ readonly conflicted: Schema.$Array<Schema.String>;
3497
+ readonly rewritten: Schema.$Array<Schema.String>;
3498
+ readonly changed: Schema.$Array<Schema.String>;
3499
+ readonly truncated: Schema.Boolean;
3500
+ }>>;
3501
+ readonly syncedTarget: Schema.optionalKey<Schema.String>;
3502
+ readonly harnessHold: Schema.optionalKey<Schema.Struct<{
3503
+ readonly reason: Schema.Literals<readonly ["out_of_quota", "rate_limited", "login_refused", "failed_to_start"]>;
3504
+ readonly until: Schema.optionalKey<Schema.String>;
3505
+ readonly scope: Schema.optionalKey<Schema.Literal<"step">>;
3506
+ }>>;
3507
+ readonly restart: Schema.optionalKey<Schema.Struct<{
3508
+ readonly reason: Schema.Literal<"login_revoked">;
3509
+ }>>;
3510
+ readonly failureSummary: Schema.optionalKey<Schema.String>;
3511
+ }>;
3512
+ }>, Schema.Void, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"DeferredDone", Schema.Struct<{
3513
+ lease: Schema.Struct<{
3514
+ readonly workUnitId: Schema.String;
3515
+ readonly leaseOwnerId: Schema.String;
3516
+ readonly runnerReplicaId: Schema.String;
3517
+ readonly leaseId: Schema.String;
3518
+ readonly attempt: Schema.Int;
3519
+ readonly fencingToken: Schema.String;
3520
+ readonly capacitySlot: Schema.String;
3521
+ }>;
3522
+ name: Schema.String;
3523
+ exit: Schema.Codec<Schema.Json, Schema.Json, never, never>;
3524
+ }>, Schema.Void, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"FinishProgram", Schema.Struct<{
3525
+ lease: Schema.Struct<{
3526
+ readonly workUnitId: Schema.String;
3527
+ readonly leaseOwnerId: Schema.String;
3528
+ readonly runnerReplicaId: Schema.String;
3529
+ readonly leaseId: Schema.String;
3530
+ readonly attempt: Schema.Int;
3531
+ readonly fencingToken: Schema.String;
3532
+ readonly capacitySlot: Schema.String;
3533
+ }>;
3534
+ outcome: Schema.Union<readonly [Schema.Struct<{
3535
+ readonly status: Schema.Literal<"completed">;
3536
+ readonly output: Schema.Codec<Schema.Json, Schema.Json, never, never>;
3537
+ }>, Schema.Struct<{
3538
+ readonly status: Schema.Literal<"failed">;
3539
+ readonly failureSummary: Schema.String;
3540
+ }>]>;
3541
+ }>, Schema.Void, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"ForgetCheckpoints", Schema.Struct<{
3542
+ stepAttemptIds: Schema.$Array<Schema.String>;
3543
+ }>, Schema.Void, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"RecordActivity", Schema.Struct<{
3544
+ lease: Schema.Struct<{
3545
+ readonly workUnitId: Schema.String;
3546
+ readonly leaseOwnerId: Schema.String;
3547
+ readonly runnerReplicaId: Schema.String;
3548
+ readonly leaseId: Schema.String;
3549
+ readonly attempt: Schema.Int;
3550
+ readonly fencingToken: Schema.String;
3551
+ readonly capacitySlot: Schema.String;
3552
+ }>;
3553
+ name: Schema.String;
3554
+ attempt: Schema.Int;
3555
+ exit: Schema.Codec<Schema.Json, Schema.Json, never, never>;
3556
+ }>, Schema.Void, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"RecordNote", Schema.Struct<{
3604
3557
  lease: Schema.Struct<{
3605
3558
  readonly workUnitId: Schema.String;
3606
3559
  readonly leaseOwnerId: Schema.String;
@@ -3611,14 +3564,61 @@ export declare const RunnerRpcs: RpcGroup.RpcGroup<Rpc.Rpc<"AdmitChild", Schema.
3611
3564
  readonly capacitySlot: Schema.String;
3612
3565
  }>;
3613
3566
  step: Schema.String;
3614
- kind: Schema.String;
3615
- title: Schema.String;
3616
3567
  text: Schema.String;
3617
- data: Schema.optional<Schema.Codec<Schema.Json, Schema.Json, never, never>>;
3618
- fileIds: Schema.optional<Schema.$Array<Schema.String>>;
3619
- }>, Schema.Struct<{
3620
- readonly artifactId: Schema.String;
3621
- }>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"Suspend", Schema.Struct<{
3568
+ artifactId: Schema.optional<Schema.String>;
3569
+ /** A `blocker` records what the Task waits on; a note when left out. */
3570
+ kind: Schema.optional<Schema.Literals<readonly ["note", "blocker"]>>;
3571
+ }>, Schema.Void, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"Release", Schema.Struct<{
3572
+ readonly workUnitId: Schema.String;
3573
+ readonly lease: Schema.Struct<{
3574
+ readonly leaseOwnerId: Schema.String;
3575
+ readonly runnerReplicaId: Schema.String;
3576
+ readonly leaseId: Schema.String;
3577
+ readonly attempt: Schema.Int;
3578
+ readonly fencingToken: Schema.String;
3579
+ readonly capacitySlot: Schema.String;
3580
+ }>;
3581
+ readonly crashed: Schema.optionalKey<Schema.Struct<{
3582
+ readonly reason: Schema.String;
3583
+ }>>;
3584
+ }>, Schema.Void, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"ReportSteer", Schema.Struct<{
3585
+ workUnitId: Schema.String;
3586
+ messageId: Schema.String;
3587
+ delivered: Schema.Boolean;
3588
+ }>, Schema.Void, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"SaveCheckpoint", Schema.Struct<{
3589
+ lease: Schema.Struct<{
3590
+ readonly workUnitId: Schema.String;
3591
+ readonly leaseOwnerId: Schema.String;
3592
+ readonly runnerReplicaId: Schema.String;
3593
+ readonly leaseId: Schema.String;
3594
+ readonly attempt: Schema.Int;
3595
+ readonly fencingToken: Schema.String;
3596
+ readonly capacitySlot: Schema.String;
3597
+ }>;
3598
+ checkpoint: Schema.Struct<{
3599
+ readonly ref: Schema.optionalKey<Schema.String>;
3600
+ readonly revision: Schema.optionalKey<Schema.String>;
3601
+ readonly session: Schema.optionalKey<Schema.Struct<{
3602
+ readonly harness: Schema.String;
3603
+ readonly id: Schema.String;
3604
+ readonly name: Schema.String;
3605
+ readonly fileId: Schema.String;
3606
+ }>>;
3607
+ }>;
3608
+ }>, Schema.Void, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"ScheduleClock", Schema.Struct<{
3609
+ lease: Schema.Struct<{
3610
+ readonly workUnitId: Schema.String;
3611
+ readonly leaseOwnerId: Schema.String;
3612
+ readonly runnerReplicaId: Schema.String;
3613
+ readonly leaseId: Schema.String;
3614
+ readonly attempt: Schema.Int;
3615
+ readonly fencingToken: Schema.String;
3616
+ readonly capacitySlot: Schema.String;
3617
+ }>;
3618
+ name: Schema.String;
3619
+ deferredName: Schema.String;
3620
+ durationMillis: Schema.Int;
3621
+ }>, Schema.Void, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"Suspend", Schema.Struct<{
3622
3622
  lease: Schema.Struct<{
3623
3623
  readonly workUnitId: Schema.String;
3624
3624
  readonly leaseOwnerId: Schema.String;