@kitman-sh/sdk 0.10.84 → 0.10.85

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 (10) hide show
  1. package/dist/build/index.js +2 -2
  2. package/dist/{chunk-3pz068kn.js → chunk-41m1ayrn.js} +1 -1
  3. package/dist/{chunk-cqknxyv9.js → chunk-x8gnbtas.js} +2 -1
  4. package/dist/loop/index.js +1 -1
  5. package/dist/program/index.js +2 -2
  6. package/package.json +1 -1
  7. package/types/packages/core/src/loop.d.ts +49 -0
  8. package/types/packages/core/src/my-teams.d.ts +60 -0
  9. package/types/packages/core/src/run-display.d.ts +9 -1
  10. package/types/packages/live/src/rpc/runner-group.d.ts +1692 -1692
package/types/packages/live/src/rpc/runner-group.d.ts CHANGED
@@ -123,24 +123,55 @@ 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<"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>;
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
+ }>]>;
142
169
  }>>;
143
- }>>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"KnownEvidence", Schema.Struct<{
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<{
144
175
  lease: Schema.Struct<{
145
176
  readonly workUnitId: Schema.String;
146
177
  readonly leaseOwnerId: Schema.String;
@@ -150,30 +181,16 @@ declare const RunnerReplicaRpcs_base: RpcGroup.RpcGroup<Rpc.Rpc<"SettledRuns", S
150
181
  readonly fencingToken: Schema.String;
151
182
  readonly capacitySlot: Schema.String;
152
183
  }>;
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<{
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<{
177
194
  readonly teamId: Schema.optionalKey<Schema.String>;
178
195
  readonly runnerReplicaId: Schema.String;
179
196
  readonly capacitySlot: Schema.String;
@@ -341,7 +358,7 @@ declare const RunnerReplicaRpcs_base: RpcGroup.RpcGroup<Rpc.Rpc<"SettledRuns", S
341
358
  readonly hosts: Schema.optionalKey<Schema.$Array<Schema.String>>;
342
359
  readonly storageOrigin: Schema.optionalKey<Schema.String>;
343
360
  }>]>>;
344
- }>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"Heartbeat", Schema.Struct<{
361
+ }>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"Complete", Schema.Struct<{
345
362
  readonly workUnitId: Schema.String;
346
363
  readonly lease: Schema.Struct<{
347
364
  readonly leaseOwnerId: Schema.String;
@@ -351,18 +368,113 @@ declare const RunnerReplicaRpcs_base: RpcGroup.RpcGroup<Rpc.Rpc<"SettledRuns", S
351
368
  readonly fencingToken: Schema.String;
352
369
  readonly capacitySlot: Schema.String;
353
370
  }>;
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<{
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<{
366
478
  lease: Schema.Struct<{
367
479
  readonly workUnitId: Schema.String;
368
480
  readonly leaseOwnerId: Schema.String;
@@ -428,9 +540,16 @@ declare const RunnerReplicaRpcs_base: RpcGroup.RpcGroup<Rpc.Rpc<"SettledRuns", S
428
540
  readonly partNumber: Schema.Int;
429
541
  }>>;
430
542
  }>]>>;
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;
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<{
434
553
  readonly leaseOwnerId: Schema.String;
435
554
  readonly runnerReplicaId: Schema.String;
436
555
  readonly leaseId: Schema.String;
@@ -438,20 +557,18 @@ declare const RunnerReplicaRpcs_base: RpcGroup.RpcGroup<Rpc.Rpc<"SettledRuns", S
438
557
  readonly fencingToken: Schema.String;
439
558
  readonly capacitySlot: Schema.String;
440
559
  }>;
441
- fileId: Schema.String;
442
- partNumbers: Schema.$Array<Schema.Int>;
443
- }>, 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;
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
+ }>>>;
452
565
  }>, Schema.Struct<{
453
- readonly bundle: Schema.String;
454
- }>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"ResumeCheckpoint", 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<{
455
572
  lease: Schema.Struct<{
456
573
  readonly workUnitId: Schema.String;
457
574
  readonly leaseOwnerId: Schema.String;
@@ -461,66 +578,12 @@ declare const RunnerReplicaRpcs_base: RpcGroup.RpcGroup<Rpc.Rpc<"SettledRuns", S
461
578
  readonly fencingToken: Schema.String;
462
579
  readonly capacitySlot: Schema.String;
463
580
  }>;
464
- }>, Schema.UndefinedOr<Schema.Struct<{
465
- readonly ref: Schema.optionalKey<Schema.String>;
466
- readonly revision: Schema.optionalKey<Schema.String>;
467
- readonly session: Schema.optionalKey<Schema.Struct<{
468
- readonly harness: Schema.String;
469
- readonly id: Schema.String;
470
- readonly name: Schema.String;
471
- readonly url: Schema.String;
472
- readonly headers: Schema.optionalKey<Schema.$Record<Schema.String, Schema.String>>;
473
- }>>;
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<{
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<{
524
587
  readonly workUnitId: Schema.String;
525
588
  readonly lease: Schema.Struct<{
526
589
  readonly leaseOwnerId: Schema.String;
@@ -530,117 +593,16 @@ declare const RunnerReplicaRpcs_base: RpcGroup.RpcGroup<Rpc.Rpc<"SettledRuns", S
530
593
  readonly fencingToken: Schema.String;
531
594
  readonly capacitySlot: Schema.String;
532
595
  }>;
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<{
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<{
604
+ lease: Schema.Struct<{
605
+ readonly workUnitId: Schema.String;
644
606
  readonly leaseOwnerId: Schema.String;
645
607
  readonly runnerReplicaId: Schema.String;
646
608
  readonly leaseId: Schema.String;
@@ -648,14 +610,17 @@ declare const RunnerReplicaRpcs_base: RpcGroup.RpcGroup<Rpc.Rpc<"SettledRuns", S
648
610
  readonly fencingToken: Schema.String;
649
611
  readonly capacitySlot: Schema.String;
650
612
  }>;
651
- readonly crashed: Schema.optionalKey<Schema.Struct<{
652
- readonly reason: Schema.String;
613
+ }>, Schema.UndefinedOr<Schema.Struct<{
614
+ readonly ref: Schema.optionalKey<Schema.String>;
615
+ readonly revision: Schema.optionalKey<Schema.String>;
616
+ readonly session: Schema.optionalKey<Schema.Struct<{
617
+ readonly harness: Schema.String;
618
+ readonly id: Schema.String;
619
+ readonly name: Schema.String;
620
+ readonly url: Schema.String;
621
+ readonly headers: Schema.optionalKey<Schema.$Record<Schema.String, Schema.String>>;
653
622
  }>>;
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<{
623
+ }>>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"SaveCheckpoint", Schema.Struct<{
659
624
  lease: Schema.Struct<{
660
625
  readonly workUnitId: Schema.String;
661
626
  readonly leaseOwnerId: Schema.String;
@@ -675,7 +640,42 @@ declare const RunnerReplicaRpcs_base: RpcGroup.RpcGroup<Rpc.Rpc<"SettledRuns", S
675
640
  readonly fileId: Schema.String;
676
641
  }>>;
677
642
  }>;
678
- }>, Schema.Void, typeof RunnerRpcError, typeof RunnerAuthentication, never>>;
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>>;
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<"CreatePlanTasks", Schema.Struct<{
751
+ declare const RunnerCapabilityRpcs_base: RpcGroup.RpcGroup<Rpc.Rpc<"AdmitChild", Schema.Struct<{
752
752
  lease: Schema.Struct<{
753
753
  readonly workUnitId: Schema.String;
754
754
  readonly leaseOwnerId: Schema.String;
@@ -758,19 +758,15 @@ declare const RunnerCapabilityRpcs_base: RpcGroup.RpcGroup<Rpc.Rpc<"CreatePlanTa
758
758
  readonly fencingToken: Schema.String;
759
759
  readonly capacitySlot: Schema.String;
760
760
  }>;
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<{
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<{
774
770
  lease: Schema.Struct<{
775
771
  readonly workUnitId: Schema.String;
776
772
  readonly leaseOwnerId: Schema.String;
@@ -780,7 +776,21 @@ declare const RunnerCapabilityRpcs_base: RpcGroup.RpcGroup<Rpc.Rpc<"CreatePlanTa
780
776
  readonly fencingToken: Schema.String;
781
777
  readonly capacitySlot: Schema.String;
782
778
  }>;
783
- }>, Schema.$Record<Schema.String, Schema.String>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"PutQuestion", Schema.Struct<{
779
+ 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;
792
+ }>>;
793
+ }>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"ApproveChangeRequest", Schema.Struct<{
784
794
  lease: Schema.Struct<{
785
795
  readonly workUnitId: Schema.String;
786
796
  readonly leaseOwnerId: Schema.String;
@@ -791,53 +801,18 @@ declare const RunnerCapabilityRpcs_base: RpcGroup.RpcGroup<Rpc.Rpc<"CreatePlanTa
791
801
  readonly capacitySlot: Schema.String;
792
802
  }>;
793
803
  step: 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>;
805
- }>>;
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<{
817
- lease: Schema.Struct<{
818
- readonly workUnitId: Schema.String;
819
- readonly leaseOwnerId: Schema.String;
820
- readonly runnerReplicaId: Schema.String;
821
- readonly leaseId: Schema.String;
822
- readonly attempt: Schema.Int;
823
- readonly fencingToken: Schema.String;
824
- readonly capacitySlot: Schema.String;
825
- }>;
826
- step: 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>;
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;
838
812
  }>, Schema.Struct<{
839
- readonly stepAttemptId: Schema.String;
840
- }>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"StartVerification", Schema.Struct<{
813
+ readonly approved: Schema.Literal<false>;
814
+ readonly reason: Schema.String;
815
+ }>]>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"AwaitEvent", Schema.Struct<{
841
816
  lease: Schema.Struct<{
842
817
  readonly workUnitId: Schema.String;
843
818
  readonly leaseOwnerId: Schema.String;
@@ -849,43 +824,19 @@ declare const RunnerCapabilityRpcs_base: RpcGroup.RpcGroup<Rpc.Rpc<"CreatePlanTa
849
824
  }>;
850
825
  step: Schema.String;
851
826
  deferredName: 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>;
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>;
861
838
  }>>>;
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<{
839
+ }>, Schema.Void, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"ClaimResource", Schema.Struct<{
889
840
  lease: Schema.Struct<{
890
841
  readonly workUnitId: Schema.String;
891
842
  readonly leaseOwnerId: Schema.String;
@@ -896,14 +847,10 @@ declare const RunnerCapabilityRpcs_base: RpcGroup.RpcGroup<Rpc.Rpc<"CreatePlanTa
896
847
  readonly capacitySlot: Schema.String;
897
848
  }>;
898
849
  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>>;
903
850
  deferredName: Schema.String;
904
- }>, Schema.Struct<{
905
- readonly runId: Schema.String;
906
- }>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"StoreArtifact", Schema.Struct<{
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<{
907
854
  lease: Schema.Struct<{
908
855
  readonly workUnitId: Schema.String;
909
856
  readonly leaseOwnerId: Schema.String;
@@ -914,14 +861,13 @@ declare const RunnerCapabilityRpcs_base: RpcGroup.RpcGroup<Rpc.Rpc<"CreatePlanTa
914
861
  readonly capacitySlot: Schema.String;
915
862
  }>;
916
863
  step: 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>>;
864
+ number: Schema.String;
865
+ head: Schema.String;
866
+ note: Schema.String;
922
867
  }>, Schema.Struct<{
923
- readonly artifactId: Schema.String;
924
- }>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"AlertTask", 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<{
925
871
  lease: Schema.Struct<{
926
872
  readonly workUnitId: Schema.String;
927
873
  readonly leaseOwnerId: Schema.String;
@@ -931,21 +877,19 @@ declare const RunnerCapabilityRpcs_base: RpcGroup.RpcGroup<Rpc.Rpc<"CreatePlanTa
931
877
  readonly fencingToken: Schema.String;
932
878
  readonly capacitySlot: Schema.String;
933
879
  }>;
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;
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"]>>;
947
888
  }>>;
948
- }>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"ReadTranscripts", Schema.Struct<{
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<{
949
893
  lease: Schema.Struct<{
950
894
  readonly workUnitId: Schema.String;
951
895
  readonly leaseOwnerId: Schema.String;
@@ -956,62 +900,17 @@ declare const RunnerCapabilityRpcs_base: RpcGroup.RpcGroup<Rpc.Rpc<"CreatePlanTa
956
900
  readonly capacitySlot: Schema.String;
957
901
  }>;
958
902
  step: Schema.String;
959
- days: Schema.Int;
960
- }>, 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<{
976
- lease: Schema.Struct<{
977
- readonly workUnitId: Schema.String;
978
- readonly leaseOwnerId: Schema.String;
979
- readonly runnerReplicaId: Schema.String;
980
- readonly leaseId: Schema.String;
981
- readonly attempt: Schema.Int;
982
- readonly fencingToken: Schema.String;
983
- readonly capacitySlot: 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>;
984
910
  }>;
985
- step: Schema.String;
986
- changeRequestId: Schema.String;
987
911
  }>, 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<{
912
+ readonly id: Schema.String;
913
+ }>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"IntegrationBranch", Schema.Struct<{
1015
914
  lease: Schema.Struct<{
1016
915
  readonly workUnitId: Schema.String;
1017
916
  readonly leaseOwnerId: Schema.String;
@@ -1021,13 +920,12 @@ declare const RunnerCapabilityRpcs_base: RpcGroup.RpcGroup<Rpc.Rpc<"CreatePlanTa
1021
920
  readonly fencingToken: Schema.String;
1022
921
  readonly capacitySlot: Schema.String;
1023
922
  }>;
1024
- step: Schema.String;
1025
- changeRequestId: Schema.String;
1026
- verification: Schema.String;
923
+ repoBindingId: Schema.optionalKey<Schema.String>;
1027
924
  }>, Schema.Struct<{
1028
- readonly head: Schema.String;
1029
- readonly status: Schema.Literals<readonly ["success", "failed"]>;
1030
- }>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"ReviewThreads", 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<{
1031
929
  lease: Schema.Struct<{
1032
930
  readonly workUnitId: Schema.String;
1033
931
  readonly leaseOwnerId: Schema.String;
@@ -1039,18 +937,16 @@ declare const RunnerCapabilityRpcs_base: RpcGroup.RpcGroup<Rpc.Rpc<"CreatePlanTa
1039
937
  }>;
1040
938
  step: Schema.String;
1041
939
  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;
1042
944
  }>, 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<{
945
+ readonly status: Schema.Literal<"conflict">;
946
+ }>, Schema.Struct<{
947
+ readonly status: Schema.Literal<"moved">;
948
+ readonly head: Schema.String;
949
+ }>]>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"OpenChangeRequests", Schema.Struct<{
1054
950
  lease: Schema.Struct<{
1055
951
  readonly workUnitId: Schema.String;
1056
952
  readonly leaseOwnerId: Schema.String;
@@ -1092,7 +988,7 @@ declare const RunnerCapabilityRpcs_base: RpcGroup.RpcGroup<Rpc.Rpc<"CreatePlanTa
1092
988
  readonly sourceBranch: Schema.String;
1093
989
  readonly body: Schema.String;
1094
990
  }>>;
1095
- }>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"Propose", Schema.Struct<{
991
+ }>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"PerformHostEffect", Schema.Struct<{
1096
992
  lease: Schema.Struct<{
1097
993
  readonly workUnitId: Schema.String;
1098
994
  readonly leaseOwnerId: Schema.String;
@@ -1103,21 +999,106 @@ declare const RunnerCapabilityRpcs_base: RpcGroup.RpcGroup<Rpc.Rpc<"CreatePlanTa
1103
999
  readonly capacitySlot: Schema.String;
1104
1000
  }>;
1105
1001
  step: Schema.String;
1106
- proposal: Schema.Union<readonly [Schema.Struct<{
1107
- readonly kind: Schema.Literal<"memory">;
1108
- readonly teamId: Schema.String;
1109
- readonly content: Schema.String;
1110
- readonly citations: Schema.NonEmptyArray<Schema.Struct<{
1111
- readonly runId: Schema.String;
1112
- readonly stepAttemptId: Schema.String;
1113
- readonly sequence: Schema.Int;
1114
- }>>;
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
+ }>>>;
1115
1013
  }>, Schema.Struct<{
1116
- readonly kind: Schema.Literal<"task">;
1014
+ readonly kind: Schema.Literal<"change_request">;
1117
1015
  readonly title: Schema.String;
1118
- readonly description: Schema.String;
1119
- readonly teamId: Schema.optionalKey<Schema.String>;
1120
- readonly key: Schema.optionalKey<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<{
1077
+ lease: Schema.Struct<{
1078
+ readonly workUnitId: Schema.String;
1079
+ readonly leaseOwnerId: Schema.String;
1080
+ readonly runnerReplicaId: Schema.String;
1081
+ readonly leaseId: Schema.String;
1082
+ readonly attempt: Schema.Int;
1083
+ readonly fencingToken: Schema.String;
1084
+ readonly capacitySlot: Schema.String;
1085
+ }>;
1086
+ step: Schema.String;
1087
+ proposal: Schema.Union<readonly [Schema.Struct<{
1088
+ readonly kind: Schema.Literal<"memory">;
1089
+ readonly teamId: Schema.String;
1090
+ readonly content: Schema.String;
1091
+ readonly citations: Schema.NonEmptyArray<Schema.Struct<{
1092
+ readonly runId: Schema.String;
1093
+ readonly stepAttemptId: Schema.String;
1094
+ readonly sequence: Schema.Int;
1095
+ }>>;
1096
+ }>, Schema.Struct<{
1097
+ readonly kind: Schema.Literal<"task">;
1098
+ readonly title: Schema.String;
1099
+ readonly description: Schema.String;
1100
+ readonly teamId: Schema.optionalKey<Schema.String>;
1101
+ readonly key: Schema.optionalKey<Schema.String>;
1121
1102
  readonly citations: Schema.NonEmptyArray<Schema.Struct<{
1122
1103
  readonly runId: Schema.String;
1123
1104
  readonly stepAttemptId: Schema.String;
@@ -1128,6 +1109,58 @@ declare const RunnerCapabilityRpcs_base: RpcGroup.RpcGroup<Rpc.Rpc<"CreatePlanTa
1128
1109
  readonly kind: Schema.Literals<readonly ["memory", "task"]>;
1129
1110
  readonly id: Schema.String;
1130
1111
  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;
1131
1164
  }>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"ReadProject", Schema.Struct<{
1132
1165
  lease: Schema.Struct<{
1133
1166
  readonly workUnitId: Schema.String;
@@ -1167,7 +1200,7 @@ declare const RunnerCapabilityRpcs_base: RpcGroup.RpcGroup<Rpc.Rpc<"CreatePlanTa
1167
1200
  readonly change: Schema.String;
1168
1201
  readonly at: Schema.String;
1169
1202
  }>>;
1170
- }>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"DraftUpdate", Schema.Struct<{
1203
+ }>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"ReadTranscripts", Schema.Struct<{
1171
1204
  lease: Schema.Struct<{
1172
1205
  readonly workUnitId: Schema.String;
1173
1206
  readonly leaseOwnerId: Schema.String;
@@ -1178,17 +1211,23 @@ declare const RunnerCapabilityRpcs_base: RpcGroup.RpcGroup<Rpc.Rpc<"CreatePlanTa
1178
1211
  readonly capacitySlot: Schema.String;
1179
1212
  }>;
1180
1213
  step: Schema.String;
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
- }>;
1214
+ days: Schema.Int;
1189
1215
  }>, Schema.Struct<{
1190
- readonly id: Schema.String;
1191
- }>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"IntegrationBranch", 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<{
1192
1231
  lease: Schema.Struct<{
1193
1232
  readonly workUnitId: Schema.String;
1194
1233
  readonly leaseOwnerId: Schema.String;
@@ -1198,12 +1237,12 @@ declare const RunnerCapabilityRpcs_base: RpcGroup.RpcGroup<Rpc.Rpc<"CreatePlanTa
1198
1237
  readonly fencingToken: Schema.String;
1199
1238
  readonly capacitySlot: Schema.String;
1200
1239
  }>;
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<{
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<{
1207
1246
  lease: Schema.Struct<{
1208
1247
  readonly workUnitId: Schema.String;
1209
1248
  readonly leaseOwnerId: Schema.String;
@@ -1214,12 +1253,11 @@ declare const RunnerCapabilityRpcs_base: RpcGroup.RpcGroup<Rpc.Rpc<"CreatePlanTa
1214
1253
  readonly capacitySlot: Schema.String;
1215
1254
  }>;
1216
1255
  step: Schema.String;
1217
- number: Schema.String;
1218
- head: Schema.String;
1219
- note: Schema.String;
1256
+ changeRequestId: Schema.String;
1257
+ verification: Schema.String;
1220
1258
  }>, Schema.Struct<{
1221
- readonly closed: Schema.Boolean;
1222
- readonly head: Schema.optionalKey<Schema.String>;
1259
+ readonly head: Schema.String;
1260
+ readonly status: Schema.Literals<readonly ["success", "failed"]>;
1223
1261
  }>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"RerunPipeline", Schema.Struct<{
1224
1262
  lease: Schema.Struct<{
1225
1263
  readonly workUnitId: Schema.String;
@@ -1237,7 +1275,7 @@ declare const RunnerCapabilityRpcs_base: RpcGroup.RpcGroup<Rpc.Rpc<"CreatePlanTa
1237
1275
  }>, Schema.Struct<{
1238
1276
  readonly head: Schema.String;
1239
1277
  readonly pipelines: Schema.Int;
1240
- }>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"PublishRelease", Schema.Struct<{
1278
+ }>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"ReviewThreads", Schema.Struct<{
1241
1279
  lease: Schema.Struct<{
1242
1280
  readonly workUnitId: Schema.String;
1243
1281
  readonly leaseOwnerId: Schema.String;
@@ -1248,15 +1286,19 @@ declare const RunnerCapabilityRpcs_base: RpcGroup.RpcGroup<Rpc.Rpc<"CreatePlanTa
1248
1286
  readonly capacitySlot: Schema.String;
1249
1287
  }>;
1250
1288
  step: Schema.String;
1251
- tag: Schema.String;
1252
- revision: Schema.optionalKey<Schema.String>;
1253
- title: Schema.String;
1254
- notes: Schema.String;
1289
+ changeRequestId: Schema.String;
1255
1290
  }>, Schema.Struct<{
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<{
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>;
1298
+ readonly body: Schema.String;
1299
+ }>>;
1300
+ }>>;
1301
+ }>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"StartAgentStep", Schema.Struct<{
1260
1302
  lease: Schema.Struct<{
1261
1303
  readonly workUnitId: Schema.String;
1262
1304
  readonly leaseOwnerId: Schema.String;
@@ -1267,75 +1309,20 @@ declare const RunnerCapabilityRpcs_base: RpcGroup.RpcGroup<Rpc.Rpc<"CreatePlanTa
1267
1309
  readonly capacitySlot: Schema.String;
1268
1310
  }>;
1269
1311
  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;
1279
- readonly body: Schema.String;
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<{
1296
- lease: Schema.Struct<{
1297
- readonly workUnitId: Schema.String;
1298
- readonly leaseOwnerId: Schema.String;
1299
- readonly runnerReplicaId: Schema.String;
1300
- readonly leaseId: Schema.String;
1301
- readonly attempt: Schema.Int;
1302
- readonly fencingToken: Schema.String;
1303
- readonly capacitySlot: Schema.String;
1304
- }>;
1305
- step: 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;
1314
- }>, Schema.Struct<{
1315
- readonly approved: Schema.Literal<false>;
1316
- readonly reason: Schema.String;
1317
- }>]>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"MergeChangeRequest", Schema.Struct<{
1318
- lease: Schema.Struct<{
1319
- readonly workUnitId: Schema.String;
1320
- readonly leaseOwnerId: Schema.String;
1321
- readonly runnerReplicaId: Schema.String;
1322
- readonly leaseId: Schema.String;
1323
- readonly attempt: Schema.Int;
1324
- readonly fencingToken: Schema.String;
1325
- readonly capacitySlot: Schema.String;
1326
- }>;
1327
- step: Schema.String;
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;
1333
- }>, 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<{
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>;
1323
+ }>, Schema.Struct<{
1324
+ readonly stepAttemptId: Schema.String;
1325
+ }>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"StartVerification", Schema.Struct<{
1339
1326
  lease: Schema.Struct<{
1340
1327
  readonly workUnitId: Schema.String;
1341
1328
  readonly leaseOwnerId: Schema.String;
@@ -1347,33 +1334,43 @@ declare const RunnerCapabilityRpcs_base: RpcGroup.RpcGroup<Rpc.Rpc<"CreatePlanTa
1347
1334
  }>;
1348
1335
  step: Schema.String;
1349
1336
  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>;
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>;
1361
1346
  }>>>;
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<{
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
+ }>>;
1371
+ }>, Schema.Struct<{
1372
+ readonly verificationId: Schema.String;
1373
+ }>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"StoreArtifact", Schema.Struct<{
1377
1374
  lease: Schema.Struct<{
1378
1375
  readonly workUnitId: Schema.String;
1379
1376
  readonly leaseOwnerId: Schema.String;
@@ -1384,11 +1381,14 @@ declare const RunnerCapabilityRpcs_base: RpcGroup.RpcGroup<Rpc.Rpc<"CreatePlanTa
1384
1381
  readonly capacitySlot: Schema.String;
1385
1382
  }>;
1386
1383
  step: Schema.String;
1384
+ kind: Schema.String;
1385
+ title: Schema.String;
1387
1386
  text: Schema.String;
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>>;
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>>;
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<"CreatePlanTasks", Schema.Struct<{
1489
+ export declare const ProgramRpcs: RpcGroup.RpcGroup<Rpc.Rpc<"AdmitChild", Schema.Struct<{
1490
1490
  lease: Schema.Struct<{
1491
1491
  readonly workUnitId: Schema.String;
1492
1492
  readonly leaseOwnerId: Schema.String;
@@ -1496,19 +1496,15 @@ export declare const ProgramRpcs: RpcGroup.RpcGroup<Rpc.Rpc<"CreatePlanTasks", S
1496
1496
  readonly fencingToken: Schema.String;
1497
1497
  readonly capacitySlot: Schema.String;
1498
1498
  }>;
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<{
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<{
1512
1508
  lease: Schema.Struct<{
1513
1509
  readonly workUnitId: Schema.String;
1514
1510
  readonly leaseOwnerId: Schema.String;
@@ -1518,7 +1514,21 @@ export declare const ProgramRpcs: RpcGroup.RpcGroup<Rpc.Rpc<"CreatePlanTasks", S
1518
1514
  readonly fencingToken: Schema.String;
1519
1515
  readonly capacitySlot: Schema.String;
1520
1516
  }>;
1521
- }>, Schema.$Record<Schema.String, Schema.String>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"CompleteRunFile", Schema.Struct<{
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<{
1522
1532
  lease: Schema.Struct<{
1523
1533
  readonly workUnitId: Schema.String;
1524
1534
  readonly leaseOwnerId: Schema.String;
@@ -1528,23 +1538,19 @@ export declare const ProgramRpcs: RpcGroup.RpcGroup<Rpc.Rpc<"CreatePlanTasks", S
1528
1538
  readonly fencingToken: Schema.String;
1529
1539
  readonly capacitySlot: Schema.String;
1530
1540
  }>;
1531
- fileId: Schema.String;
1532
- parts: Schema.optional<Schema.$Array<Schema.Struct<{
1533
- readonly partNumber: Schema.Int;
1534
- readonly etag: Schema.String;
1535
- }>>>;
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;
1536
1550
  }>, 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<{
1551
+ readonly approved: Schema.Literal<false>;
1552
+ readonly reason: Schema.String;
1553
+ }>]>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"AwaitEvent", Schema.Struct<{
1548
1554
  lease: Schema.Struct<{
1549
1555
  readonly workUnitId: Schema.String;
1550
1556
  readonly leaseOwnerId: Schema.String;
@@ -1555,29 +1561,20 @@ export declare const ProgramRpcs: RpcGroup.RpcGroup<Rpc.Rpc<"CreatePlanTasks", S
1555
1561
  readonly capacitySlot: Schema.String;
1556
1562
  }>;
1557
1563
  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>;
1577
1564
  deferredName: Schema.String;
1578
- }>, Schema.Struct<{
1579
- readonly questionId: Schema.String;
1580
- }>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"StartAgentStep", Schema.Struct<{
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<{
1581
1578
  lease: Schema.Struct<{
1582
1579
  readonly workUnitId: Schema.String;
1583
1580
  readonly leaseOwnerId: Schema.String;
@@ -1589,19 +1586,9 @@ export declare const ProgramRpcs: RpcGroup.RpcGroup<Rpc.Rpc<"CreatePlanTasks", S
1589
1586
  }>;
1590
1587
  step: Schema.String;
1591
1588
  deferredName: Schema.String;
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<{
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<{
1605
1592
  lease: Schema.Struct<{
1606
1593
  readonly workUnitId: Schema.String;
1607
1594
  readonly leaseOwnerId: Schema.String;
@@ -1612,44 +1599,13 @@ export declare const ProgramRpcs: RpcGroup.RpcGroup<Rpc.Rpc<"CreatePlanTasks", S
1612
1599
  readonly capacitySlot: Schema.String;
1613
1600
  }>;
1614
1601
  step: 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
- }>>;
1602
+ number: Schema.String;
1603
+ head: Schema.String;
1604
+ note: Schema.String;
1650
1605
  }>, Schema.Struct<{
1651
- readonly verificationId: Schema.String;
1652
- }>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"AdmitChild", 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<{
1653
1609
  lease: Schema.Struct<{
1654
1610
  readonly workUnitId: Schema.String;
1655
1611
  readonly leaseOwnerId: Schema.String;
@@ -1659,15 +1615,23 @@ export declare const ProgramRpcs: RpcGroup.RpcGroup<Rpc.Rpc<"CreatePlanTasks", S
1659
1615
  readonly fencingToken: Schema.String;
1660
1616
  readonly capacitySlot: Schema.String;
1661
1617
  }>;
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;
1618
+ fileId: Schema.String;
1619
+ parts: Schema.optional<Schema.$Array<Schema.Struct<{
1620
+ readonly partNumber: Schema.Int;
1621
+ readonly etag: Schema.String;
1622
+ }>>>;
1668
1623
  }>, Schema.Struct<{
1624
+ readonly id: Schema.String;
1669
1625
  readonly runId: Schema.String;
1670
- }>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"StoreArtifact", Schema.Struct<{
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<{
1671
1635
  lease: Schema.Struct<{
1672
1636
  readonly workUnitId: Schema.String;
1673
1637
  readonly leaseOwnerId: Schema.String;
@@ -1677,15 +1641,19 @@ export declare const ProgramRpcs: RpcGroup.RpcGroup<Rpc.Rpc<"CreatePlanTasks", S
1677
1641
  readonly fencingToken: Schema.String;
1678
1642
  readonly capacitySlot: Schema.String;
1679
1643
  }>;
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<{
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<{
1689
1657
  lease: Schema.Struct<{
1690
1658
  readonly workUnitId: Schema.String;
1691
1659
  readonly leaseOwnerId: Schema.String;
@@ -1696,20 +1664,40 @@ export declare const ProgramRpcs: RpcGroup.RpcGroup<Rpc.Rpc<"CreatePlanTasks", S
1696
1664
  readonly capacitySlot: Schema.String;
1697
1665
  }>;
1698
1666
  step: 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"]>>;
1667
+ name: Schema.String;
1668
+ caption: Schema.optional<Schema.String>;
1669
+ contentType: Schema.String;
1670
+ byteSize: Schema.Int;
1671
+ sha256: Schema.String;
1704
1672
  }>, Schema.Struct<{
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"]>;
1673
+ readonly file: Schema.Struct<{
1674
+ readonly id: Schema.String;
1710
1675
  readonly runId: Schema.String;
1711
- }>>;
1712
- }>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"ReadTranscripts", Schema.Struct<{
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<{
1713
1701
  lease: Schema.Struct<{
1714
1702
  readonly workUnitId: Schema.String;
1715
1703
  readonly leaseOwnerId: Schema.String;
@@ -1719,24 +1707,9 @@ export declare const ProgramRpcs: RpcGroup.RpcGroup<Rpc.Rpc<"CreatePlanTasks", S
1719
1707
  readonly fencingToken: Schema.String;
1720
1708
  readonly capacitySlot: Schema.String;
1721
1709
  }>;
1722
- step: Schema.String;
1723
- days: Schema.Int;
1724
- }>, 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<{
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<{
1740
1713
  lease: Schema.Struct<{
1741
1714
  readonly workUnitId: Schema.String;
1742
1715
  readonly leaseOwnerId: Schema.String;
@@ -1747,35 +1720,17 @@ export declare const ProgramRpcs: RpcGroup.RpcGroup<Rpc.Rpc<"CreatePlanTasks", S
1747
1720
  readonly capacitySlot: Schema.String;
1748
1721
  }>;
1749
1722
  step: Schema.String;
1750
- changeRequestId: 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
+ }>;
1751
1731
  }>, 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<{
1732
+ readonly id: Schema.String;
1733
+ }>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"FinishProgram", Schema.Struct<{
1779
1734
  lease: Schema.Struct<{
1780
1735
  readonly workUnitId: Schema.String;
1781
1736
  readonly leaseOwnerId: Schema.String;
@@ -1785,13 +1740,29 @@ export declare const ProgramRpcs: RpcGroup.RpcGroup<Rpc.Rpc<"CreatePlanTasks", S
1785
1740
  readonly fencingToken: Schema.String;
1786
1741
  readonly capacitySlot: Schema.String;
1787
1742
  }>;
1788
- step: Schema.String;
1789
- changeRequestId: Schema.String;
1790
- verification: Schema.String;
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<{
1751
+ lease: Schema.Struct<{
1752
+ readonly workUnitId: Schema.String;
1753
+ readonly leaseOwnerId: Schema.String;
1754
+ readonly runnerReplicaId: Schema.String;
1755
+ readonly leaseId: Schema.String;
1756
+ readonly attempt: Schema.Int;
1757
+ readonly fencingToken: Schema.String;
1758
+ readonly capacitySlot: Schema.String;
1759
+ }>;
1760
+ repoBindingId: Schema.optionalKey<Schema.String>;
1791
1761
  }>, 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<{
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<{
1795
1766
  lease: Schema.Struct<{
1796
1767
  readonly workUnitId: Schema.String;
1797
1768
  readonly leaseOwnerId: Schema.String;
@@ -1803,18 +1774,16 @@ export declare const ProgramRpcs: RpcGroup.RpcGroup<Rpc.Rpc<"CreatePlanTasks", S
1803
1774
  }>;
1804
1775
  step: Schema.String;
1805
1776
  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;
1806
1781
  }>, 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<{
1782
+ readonly status: Schema.Literal<"conflict">;
1783
+ }>, Schema.Struct<{
1784
+ readonly status: Schema.Literal<"moved">;
1785
+ readonly head: Schema.String;
1786
+ }>]>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"OpenChangeRequests", Schema.Struct<{
1818
1787
  lease: Schema.Struct<{
1819
1788
  readonly workUnitId: Schema.String;
1820
1789
  readonly leaseOwnerId: Schema.String;
@@ -1856,7 +1825,7 @@ export declare const ProgramRpcs: RpcGroup.RpcGroup<Rpc.Rpc<"CreatePlanTasks", S
1856
1825
  readonly sourceBranch: Schema.String;
1857
1826
  readonly body: Schema.String;
1858
1827
  }>>;
1859
- }>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"Propose", Schema.Struct<{
1828
+ }>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"PerformHostEffect", Schema.Struct<{
1860
1829
  lease: Schema.Struct<{
1861
1830
  readonly workUnitId: Schema.String;
1862
1831
  readonly leaseOwnerId: Schema.String;
@@ -1867,32 +1836,32 @@ export declare const ProgramRpcs: RpcGroup.RpcGroup<Rpc.Rpc<"CreatePlanTasks", S
1867
1836
  readonly capacitySlot: Schema.String;
1868
1837
  }>;
1869
1838
  step: Schema.String;
1870
- proposal: Schema.Union<readonly [Schema.Struct<{
1871
- readonly kind: Schema.Literal<"memory">;
1872
- readonly teamId: Schema.String;
1873
- readonly content: Schema.String;
1874
- readonly citations: Schema.NonEmptyArray<Schema.Struct<{
1875
- readonly runId: Schema.String;
1876
- readonly stepAttemptId: Schema.String;
1877
- readonly sequence: Schema.Int;
1878
- }>>;
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
+ }>>>;
1879
1850
  }>, Schema.Struct<{
1880
- readonly kind: Schema.Literal<"task">;
1851
+ readonly kind: Schema.Literal<"change_request">;
1881
1852
  readonly title: Schema.String;
1882
- readonly description: Schema.String;
1883
- readonly teamId: Schema.optionalKey<Schema.String>;
1884
- readonly key: Schema.optionalKey<Schema.String>;
1885
- readonly citations: Schema.NonEmptyArray<Schema.Struct<{
1886
- readonly runId: Schema.String;
1887
- readonly stepAttemptId: Schema.String;
1888
- readonly sequence: Schema.Int;
1889
- }>>;
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>;
1890
1859
  }>]>;
1891
- }>, Schema.Struct<{
1892
- readonly kind: Schema.Literals<readonly ["memory", "task"]>;
1860
+ }>, Schema.UndefinedOr<Schema.Struct<{
1893
1861
  readonly id: Schema.String;
1894
- readonly matched: Schema.optionalKey<Schema.Boolean>;
1895
- }>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"ReadProject", Schema.Struct<{
1862
+ readonly number: Schema.String;
1863
+ readonly url: Schema.String;
1864
+ }>>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"PipelineStatus", Schema.Struct<{
1896
1865
  lease: Schema.Struct<{
1897
1866
  readonly workUnitId: Schema.String;
1898
1867
  readonly leaseOwnerId: Schema.String;
@@ -1903,35 +1872,35 @@ export declare const ProgramRpcs: RpcGroup.RpcGroup<Rpc.Rpc<"CreatePlanTasks", S
1903
1872
  readonly capacitySlot: Schema.String;
1904
1873
  }>;
1905
1874
  step: Schema.String;
1906
- projectId: Schema.String;
1875
+ changeRequestId: Schema.String;
1907
1876
  }>, Schema.Struct<{
1908
- readonly project: Schema.Struct<{
1909
- readonly id: Schema.String;
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<{
1910
1881
  readonly name: Schema.String;
1911
- }>;
1912
- readonly health: Schema.optionalKey<Schema.Literals<readonly ["on_track", "at_risk", "off_track"]>>;
1913
- readonly since: Schema.optionalKey<Schema.String>;
1914
- readonly runs: Schema.$Array<Schema.Struct<{
1915
- readonly runId: Schema.String;
1916
- readonly loopId: Schema.String;
1917
- readonly status: Schema.String;
1918
- readonly taskKey: Schema.optionalKey<Schema.String>;
1919
- readonly taskTitle: Schema.optionalKey<Schema.String>;
1920
- readonly summary: Schema.optionalKey<Schema.String>;
1921
- readonly entries: Schema.$Array<Schema.Struct<{
1922
- readonly stepAttemptId: Schema.String;
1923
- readonly sequence: Schema.Int;
1924
- readonly kind: Schema.String;
1925
- readonly text: Schema.String;
1926
- }>>;
1882
+ readonly status: Schema.Literals<readonly ["running", "success", "failed", "skipped"]>;
1883
+ readonly url: Schema.optionalKey<Schema.String>;
1884
+ readonly logTail: Schema.optionalKey<Schema.String>;
1927
1885
  }>>;
1928
- readonly taskChanges: Schema.$Array<Schema.Struct<{
1929
- readonly taskKey: Schema.String;
1930
- readonly title: Schema.String;
1931
- readonly change: Schema.String;
1932
- readonly at: Schema.String;
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
+ }>>;
1933
1902
  }>>;
1934
- }>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"DraftUpdate", Schema.Struct<{
1903
+ }>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"ProgramSecrets", Schema.Struct<{
1935
1904
  lease: Schema.Struct<{
1936
1905
  readonly workUnitId: Schema.String;
1937
1906
  readonly leaseOwnerId: Schema.String;
@@ -1941,18 +1910,7 @@ export declare const ProgramRpcs: RpcGroup.RpcGroup<Rpc.Rpc<"CreatePlanTasks", S
1941
1910
  readonly fencingToken: Schema.String;
1942
1911
  readonly capacitySlot: Schema.String;
1943
1912
  }>;
1944
- step: Schema.String;
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
- }>;
1953
- }>, Schema.Struct<{
1954
- readonly id: Schema.String;
1955
- }>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"IntegrationBranch", Schema.Struct<{
1913
+ }>, Schema.$Record<Schema.String, Schema.String>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"Propose", Schema.Struct<{
1956
1914
  lease: Schema.Struct<{
1957
1915
  readonly workUnitId: Schema.String;
1958
1916
  readonly leaseOwnerId: Schema.String;
@@ -1962,12 +1920,33 @@ export declare const ProgramRpcs: RpcGroup.RpcGroup<Rpc.Rpc<"CreatePlanTasks", S
1962
1920
  readonly fencingToken: Schema.String;
1963
1921
  readonly capacitySlot: Schema.String;
1964
1922
  }>;
1965
- repoBindingId: Schema.optionalKey<Schema.String>;
1923
+ step: Schema.String;
1924
+ proposal: Schema.Union<readonly [Schema.Struct<{
1925
+ readonly kind: Schema.Literal<"memory">;
1926
+ readonly teamId: Schema.String;
1927
+ readonly content: Schema.String;
1928
+ readonly citations: Schema.NonEmptyArray<Schema.Struct<{
1929
+ readonly runId: Schema.String;
1930
+ readonly stepAttemptId: Schema.String;
1931
+ readonly sequence: Schema.Int;
1932
+ }>>;
1933
+ }>, Schema.Struct<{
1934
+ readonly kind: Schema.Literal<"task">;
1935
+ readonly title: Schema.String;
1936
+ readonly description: Schema.String;
1937
+ readonly teamId: Schema.optionalKey<Schema.String>;
1938
+ readonly key: Schema.optionalKey<Schema.String>;
1939
+ readonly citations: Schema.NonEmptyArray<Schema.Struct<{
1940
+ readonly runId: Schema.String;
1941
+ readonly stepAttemptId: Schema.String;
1942
+ readonly sequence: Schema.Int;
1943
+ }>>;
1944
+ }>]>;
1966
1945
  }>, 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<{
1946
+ readonly kind: Schema.Literals<readonly ["memory", "task"]>;
1947
+ readonly id: Schema.String;
1948
+ readonly matched: Schema.optionalKey<Schema.Boolean>;
1949
+ }>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"PublishRelease", Schema.Struct<{
1971
1950
  lease: Schema.Struct<{
1972
1951
  readonly workUnitId: Schema.String;
1973
1952
  readonly leaseOwnerId: Schema.String;
@@ -1978,13 +1957,15 @@ export declare const ProgramRpcs: RpcGroup.RpcGroup<Rpc.Rpc<"CreatePlanTasks", S
1978
1957
  readonly capacitySlot: Schema.String;
1979
1958
  }>;
1980
1959
  step: Schema.String;
1981
- number: Schema.String;
1982
- head: Schema.String;
1983
- note: Schema.String;
1960
+ tag: Schema.String;
1961
+ revision: Schema.optionalKey<Schema.String>;
1962
+ title: Schema.String;
1963
+ notes: Schema.String;
1984
1964
  }>, 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<{
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<{
1988
1969
  lease: Schema.Struct<{
1989
1970
  readonly workUnitId: Schema.String;
1990
1971
  readonly leaseOwnerId: Schema.String;
@@ -1995,13 +1976,29 @@ export declare const ProgramRpcs: RpcGroup.RpcGroup<Rpc.Rpc<"CreatePlanTasks", S
1995
1976
  readonly capacitySlot: Schema.String;
1996
1977
  }>;
1997
1978
  step: Schema.String;
1998
- changeRequestId: Schema.optionalKey<Schema.String>;
1999
- ref: Schema.optionalKey<Schema.String>;
2000
- all: Schema.optionalKey<Schema.Boolean>;
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;
2001
1999
  }>, Schema.Struct<{
2002
- readonly head: Schema.String;
2003
- readonly pipelines: Schema.Int;
2004
- }>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"PublishRelease", Schema.Struct<{
2000
+ readonly questionId: Schema.String;
2001
+ }>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"ReadProject", Schema.Struct<{
2005
2002
  lease: Schema.Struct<{
2006
2003
  readonly workUnitId: Schema.String;
2007
2004
  readonly leaseOwnerId: Schema.String;
@@ -2012,15 +2009,35 @@ export declare const ProgramRpcs: RpcGroup.RpcGroup<Rpc.Rpc<"CreatePlanTasks", S
2012
2009
  readonly capacitySlot: Schema.String;
2013
2010
  }>;
2014
2011
  step: Schema.String;
2015
- tag: Schema.String;
2016
- revision: Schema.optionalKey<Schema.String>;
2017
- title: Schema.String;
2018
- notes: Schema.String;
2012
+ projectId: Schema.String;
2019
2013
  }>, 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<{
2014
+ readonly project: Schema.Struct<{
2015
+ readonly id: Schema.String;
2016
+ readonly name: Schema.String;
2017
+ }>;
2018
+ readonly health: Schema.optionalKey<Schema.Literals<readonly ["on_track", "at_risk", "off_track"]>>;
2019
+ readonly since: Schema.optionalKey<Schema.String>;
2020
+ readonly runs: Schema.$Array<Schema.Struct<{
2021
+ readonly runId: Schema.String;
2022
+ readonly loopId: Schema.String;
2023
+ readonly status: Schema.String;
2024
+ readonly taskKey: Schema.optionalKey<Schema.String>;
2025
+ readonly taskTitle: Schema.optionalKey<Schema.String>;
2026
+ readonly summary: Schema.optionalKey<Schema.String>;
2027
+ readonly entries: Schema.$Array<Schema.Struct<{
2028
+ readonly stepAttemptId: Schema.String;
2029
+ readonly sequence: Schema.Int;
2030
+ readonly kind: Schema.String;
2031
+ readonly text: Schema.String;
2032
+ }>>;
2033
+ }>>;
2034
+ readonly taskChanges: Schema.$Array<Schema.Struct<{
2035
+ readonly taskKey: Schema.String;
2036
+ readonly title: Schema.String;
2037
+ readonly change: Schema.String;
2038
+ readonly at: Schema.String;
2039
+ }>>;
2040
+ }>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"ReadTranscripts", Schema.Struct<{
2024
2041
  lease: Schema.Struct<{
2025
2042
  readonly workUnitId: Schema.String;
2026
2043
  readonly leaseOwnerId: Schema.String;
@@ -2031,40 +2048,23 @@ export declare const ProgramRpcs: RpcGroup.RpcGroup<Rpc.Rpc<"CreatePlanTasks", S
2031
2048
  readonly capacitySlot: Schema.String;
2032
2049
  }>;
2033
2050
  step: Schema.String;
2034
- name: Schema.String;
2035
- caption: Schema.optional<Schema.String>;
2036
- contentType: Schema.String;
2037
- byteSize: Schema.Int;
2038
- sha256: Schema.String;
2051
+ days: Schema.Int;
2039
2052
  }>, Schema.Struct<{
2040
- readonly file: Schema.Struct<{
2041
- readonly id: Schema.String;
2053
+ readonly runs: Schema.$Array<Schema.Struct<{
2042
2054
  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;
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
2065
  }>>;
2066
- }>]>>;
2067
- }>, Schema.Union<readonly [typeof RunnerRpcError, typeof RunFileRefused]>, typeof RunnerAuthentication, never> | Rpc.Rpc<"RunFileParts", Schema.Struct<{
2066
+ }>>;
2067
+ }>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"RecordActivity", Schema.Struct<{
2068
2068
  lease: Schema.Struct<{
2069
2069
  readonly workUnitId: Schema.String;
2070
2070
  readonly leaseOwnerId: Schema.String;
@@ -2074,16 +2074,10 @@ export declare const ProgramRpcs: RpcGroup.RpcGroup<Rpc.Rpc<"CreatePlanTasks", S
2074
2074
  readonly fencingToken: Schema.String;
2075
2075
  readonly capacitySlot: Schema.String;
2076
2076
  }>;
2077
- fileId: Schema.String;
2078
- partNumbers: Schema.$Array<Schema.Int>;
2079
- }>, Schema.Struct<{
2080
- readonly parts: Schema.$Array<Schema.Struct<{
2081
- readonly url: Schema.String;
2082
- readonly headers: Schema.optionalKey<Schema.$Record<Schema.String, Schema.String>>;
2083
- readonly expiresAt: Schema.String;
2084
- readonly partNumber: Schema.Int;
2085
- }>>;
2086
- }>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"PerformHostEffect", Schema.Struct<{
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<{
2087
2081
  lease: Schema.Struct<{
2088
2082
  readonly workUnitId: Schema.String;
2089
2083
  readonly leaseOwnerId: Schema.String;
@@ -2094,32 +2088,11 @@ export declare const ProgramRpcs: RpcGroup.RpcGroup<Rpc.Rpc<"CreatePlanTasks", S
2094
2088
  readonly capacitySlot: Schema.String;
2095
2089
  }>;
2096
2090
  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<{
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<{
2123
2096
  lease: Schema.Struct<{
2124
2097
  readonly workUnitId: Schema.String;
2125
2098
  readonly leaseOwnerId: Schema.String;
@@ -2131,17 +2104,11 @@ export declare const ProgramRpcs: RpcGroup.RpcGroup<Rpc.Rpc<"CreatePlanTasks", S
2131
2104
  }>;
2132
2105
  step: Schema.String;
2133
2106
  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;
2107
+ verification: Schema.String;
2141
2108
  }>, Schema.Struct<{
2142
- readonly approved: Schema.Literal<false>;
2143
- readonly reason: Schema.String;
2144
- }>]>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"MergeChangeRequest", Schema.Struct<{
2109
+ readonly head: Schema.String;
2110
+ readonly status: Schema.Literals<readonly ["success", "failed"]>;
2111
+ }>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"RerunPipeline", Schema.Struct<{
2145
2112
  lease: Schema.Struct<{
2146
2113
  readonly workUnitId: Schema.String;
2147
2114
  readonly leaseOwnerId: Schema.String;
@@ -2152,17 +2119,13 @@ export declare const ProgramRpcs: RpcGroup.RpcGroup<Rpc.Rpc<"CreatePlanTasks", S
2152
2119
  readonly capacitySlot: Schema.String;
2153
2120
  }>;
2154
2121
  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">;
2122
+ changeRequestId: Schema.optionalKey<Schema.String>;
2123
+ ref: Schema.optionalKey<Schema.String>;
2124
+ all: Schema.optionalKey<Schema.Boolean>;
2162
2125
  }>, Schema.Struct<{
2163
- readonly status: Schema.Literal<"moved">;
2164
2126
  readonly head: Schema.String;
2165
- }>]>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"AwaitEvent", Schema.Struct<{
2127
+ readonly pipelines: Schema.Int;
2128
+ }>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"ReviewThreads", Schema.Struct<{
2166
2129
  lease: Schema.Struct<{
2167
2130
  readonly workUnitId: Schema.String;
2168
2131
  readonly leaseOwnerId: Schema.String;
@@ -2173,20 +2136,19 @@ export declare const ProgramRpcs: RpcGroup.RpcGroup<Rpc.Rpc<"CreatePlanTasks", S
2173
2136
  readonly capacitySlot: Schema.String;
2174
2137
  }>;
2175
2138
  step: Schema.String;
2176
- deferredName: Schema.String;
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>;
2188
- }>>>;
2189
- }>, Schema.Void, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"ClaimResource", Schema.Struct<{
2139
+ changeRequestId: Schema.String;
2140
+ }>, Schema.Struct<{
2141
+ readonly threads: Schema.$Array<Schema.Struct<{
2142
+ 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;
2149
+ }>>;
2150
+ }>>;
2151
+ }>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"RunFileParts", Schema.Struct<{
2190
2152
  lease: Schema.Struct<{
2191
2153
  readonly workUnitId: Schema.String;
2192
2154
  readonly leaseOwnerId: Schema.String;
@@ -2196,11 +2158,16 @@ export declare const ProgramRpcs: RpcGroup.RpcGroup<Rpc.Rpc<"CreatePlanTasks", S
2196
2158
  readonly fencingToken: Schema.String;
2197
2159
  readonly capacitySlot: Schema.String;
2198
2160
  }>;
2199
- step: Schema.String;
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<{
2161
+ fileId: Schema.String;
2162
+ partNumbers: Schema.$Array<Schema.Int>;
2163
+ }>, Schema.Struct<{
2164
+ readonly parts: Schema.$Array<Schema.Struct<{
2165
+ readonly url: Schema.String;
2166
+ readonly headers: Schema.optionalKey<Schema.$Record<Schema.String, Schema.String>>;
2167
+ readonly expiresAt: Schema.String;
2168
+ readonly partNumber: Schema.Int;
2169
+ }>>;
2170
+ }>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"ScheduleClock", Schema.Struct<{
2204
2171
  lease: Schema.Struct<{
2205
2172
  readonly workUnitId: Schema.String;
2206
2173
  readonly leaseOwnerId: Schema.String;
@@ -2211,8 +2178,9 @@ export declare const ProgramRpcs: RpcGroup.RpcGroup<Rpc.Rpc<"CreatePlanTasks", S
2211
2178
  readonly capacitySlot: Schema.String;
2212
2179
  }>;
2213
2180
  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<{
2181
+ deferredName: Schema.String;
2182
+ durationMillis: Schema.Int;
2183
+ }>, Schema.Void, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"StartAgentStep", Schema.Struct<{
2216
2184
  lease: Schema.Struct<{
2217
2185
  readonly workUnitId: Schema.String;
2218
2186
  readonly leaseOwnerId: Schema.String;
@@ -2222,14 +2190,21 @@ export declare const ProgramRpcs: RpcGroup.RpcGroup<Rpc.Rpc<"CreatePlanTasks", S
2222
2190
  readonly fencingToken: Schema.String;
2223
2191
  readonly capacitySlot: Schema.String;
2224
2192
  }>;
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<{
2193
+ 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>;
2205
+ }>, Schema.Struct<{
2206
+ readonly stepAttemptId: Schema.String;
2207
+ }>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"StartVerification", Schema.Struct<{
2233
2208
  lease: Schema.Struct<{
2234
2209
  readonly workUnitId: Schema.String;
2235
2210
  readonly leaseOwnerId: Schema.String;
@@ -2239,10 +2214,45 @@ export declare const ProgramRpcs: RpcGroup.RpcGroup<Rpc.Rpc<"CreatePlanTasks", S
2239
2214
  readonly fencingToken: Schema.String;
2240
2215
  readonly capacitySlot: Schema.String;
2241
2216
  }>;
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<{
2217
+ step: Schema.String;
2218
+ 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>;
2228
+ }>>>;
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<{
2246
2256
  lease: Schema.Struct<{
2247
2257
  readonly workUnitId: Schema.String;
2248
2258
  readonly leaseOwnerId: Schema.String;
@@ -2253,11 +2263,14 @@ export declare const ProgramRpcs: RpcGroup.RpcGroup<Rpc.Rpc<"CreatePlanTasks", S
2253
2263
  readonly capacitySlot: Schema.String;
2254
2264
  }>;
2255
2265
  step: Schema.String;
2266
+ kind: Schema.String;
2267
+ title: Schema.String;
2256
2268
  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<{
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<{
2261
2274
  lease: Schema.Struct<{
2262
2275
  readonly workUnitId: Schema.String;
2263
2276
  readonly leaseOwnerId: Schema.String;
@@ -2267,10 +2280,9 @@ export declare const ProgramRpcs: RpcGroup.RpcGroup<Rpc.Rpc<"CreatePlanTasks", S
2267
2280
  readonly fencingToken: Schema.String;
2268
2281
  readonly capacitySlot: Schema.String;
2269
2282
  }>;
2270
- name: Schema.String;
2271
- deferredName: Schema.String;
2272
- durationMillis: Schema.Int;
2273
- }>, Schema.Void, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"Suspend", Schema.Struct<{
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<{
2274
2286
  lease: Schema.Struct<{
2275
2287
  readonly workUnitId: Schema.String;
2276
2288
  readonly leaseOwnerId: Schema.String;
@@ -2280,26 +2292,15 @@ export declare const ProgramRpcs: RpcGroup.RpcGroup<Rpc.Rpc<"CreatePlanTasks", S
2280
2292
  readonly fencingToken: Schema.String;
2281
2293
  readonly capacitySlot: Schema.String;
2282
2294
  }>;
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<{
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<{
2303
2304
  lease: Schema.Struct<{
2304
2305
  readonly workUnitId: Schema.String;
2305
2306
  readonly leaseOwnerId: Schema.String;
@@ -2309,12 +2310,65 @@ export declare const RunnerRpcs: RpcGroup.RpcGroup<Rpc.Rpc<"SettledRuns", Schema
2309
2310
  readonly fencingToken: Schema.String;
2310
2311
  readonly capacitySlot: Schema.String;
2311
2312
  }>;
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<{
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<{
2318
2372
  lease: Schema.Struct<{
2319
2373
  readonly workUnitId: Schema.String;
2320
2374
  readonly leaseOwnerId: Schema.String;
@@ -2324,19 +2378,19 @@ export declare const RunnerRpcs: RpcGroup.RpcGroup<Rpc.Rpc<"SettledRuns", Schema
2324
2378
  readonly fencingToken: Schema.String;
2325
2379
  readonly capacitySlot: Schema.String;
2326
2380
  }>;
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"]>>;
2335
- }>>;
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<{
2381
+ 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<{
2340
2394
  lease: Schema.Struct<{
2341
2395
  readonly workUnitId: Schema.String;
2342
2396
  readonly leaseOwnerId: Schema.String;
@@ -2346,29 +2400,48 @@ export declare const RunnerRpcs: RpcGroup.RpcGroup<Rpc.Rpc<"SettledRuns", Schema
2346
2400
  readonly fencingToken: Schema.String;
2347
2401
  readonly capacitySlot: Schema.String;
2348
2402
  }>;
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<{
2368
- readonly teamId: Schema.optionalKey<Schema.String>;
2369
- readonly runnerReplicaId: Schema.String;
2370
- readonly capacitySlot: Schema.String;
2371
- readonly idempotencyKey: Schema.String;
2403
+ step: Schema.String;
2404
+ 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<{
2422
+ lease: Schema.Struct<{
2423
+ readonly workUnitId: Schema.String;
2424
+ readonly leaseOwnerId: Schema.String;
2425
+ readonly runnerReplicaId: Schema.String;
2426
+ readonly leaseId: Schema.String;
2427
+ readonly attempt: Schema.Int;
2428
+ readonly fencingToken: Schema.String;
2429
+ readonly capacitySlot: Schema.String;
2430
+ }>;
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;
2439
+ }>>;
2440
+ }>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"Claim", Schema.Struct<{
2441
+ readonly teamId: Schema.optionalKey<Schema.String>;
2442
+ readonly runnerReplicaId: Schema.String;
2443
+ readonly capacitySlot: Schema.String;
2444
+ readonly idempotencyKey: Schema.String;
2372
2445
  readonly leaseDurationSeconds: Schema.optionalKey<Schema.Int>;
2373
2446
  }>, Schema.Struct<{
2374
2447
  readonly workUnit: Schema.optionalKey<Schema.Union<readonly [Schema.Struct<{
@@ -2532,7 +2605,38 @@ export declare const RunnerRpcs: RpcGroup.RpcGroup<Rpc.Rpc<"SettledRuns", Schema
2532
2605
  readonly hosts: Schema.optionalKey<Schema.$Array<Schema.String>>;
2533
2606
  readonly storageOrigin: Schema.optionalKey<Schema.String>;
2534
2607
  }>]>>;
2535
- }>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"Heartbeat", Schema.Struct<{
2608
+ }>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"ClaimResource", Schema.Struct<{
2609
+ lease: Schema.Struct<{
2610
+ readonly workUnitId: Schema.String;
2611
+ readonly leaseOwnerId: Schema.String;
2612
+ readonly runnerReplicaId: Schema.String;
2613
+ readonly leaseId: Schema.String;
2614
+ readonly attempt: Schema.Int;
2615
+ readonly fencingToken: Schema.String;
2616
+ readonly capacitySlot: Schema.String;
2617
+ }>;
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<{
2536
2640
  readonly workUnitId: Schema.String;
2537
2641
  readonly lease: Schema.Struct<{
2538
2642
  readonly leaseOwnerId: Schema.String;
@@ -2542,18 +2646,113 @@ export declare const RunnerRpcs: RpcGroup.RpcGroup<Rpc.Rpc<"SettledRuns", Schema
2542
2646
  readonly fencingToken: Schema.String;
2543
2647
  readonly capacitySlot: Schema.String;
2544
2648
  }>;
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<{
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<{
2557
2756
  lease: Schema.Struct<{
2558
2757
  readonly workUnitId: Schema.String;
2559
2758
  readonly leaseOwnerId: Schema.String;
@@ -2645,7 +2844,7 @@ export declare const RunnerRpcs: RpcGroup.RpcGroup<Rpc.Rpc<"SettledRuns", Schema
2645
2844
  readonly partNumber: Schema.Int;
2646
2845
  }>>;
2647
2846
  }>]>>;
2648
- }>, Schema.Union<readonly [typeof RunnerRpcError, typeof RunFileRefused]>, typeof RunnerAuthentication, never> | Rpc.Rpc<"CheckpointFileParts", Schema.Struct<{
2847
+ }>, Schema.Union<readonly [typeof RunnerRpcError, typeof RunFileRefused]>, typeof RunnerAuthentication, never> | Rpc.Rpc<"CreatePlanTasks", Schema.Struct<{
2649
2848
  lease: Schema.Struct<{
2650
2849
  readonly workUnitId: Schema.String;
2651
2850
  readonly leaseOwnerId: Schema.String;
@@ -2655,20 +2854,75 @@ export declare const RunnerRpcs: RpcGroup.RpcGroup<Rpc.Rpc<"SettledRuns", Schema
2655
2854
  readonly fencingToken: Schema.String;
2656
2855
  readonly capacitySlot: Schema.String;
2657
2856
  }>;
2658
- fileId: Schema.String;
2659
- partNumbers: Schema.$Array<Schema.Int>;
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<{
2870
+ lease: Schema.Struct<{
2871
+ readonly workUnitId: Schema.String;
2872
+ readonly leaseOwnerId: Schema.String;
2873
+ readonly runnerReplicaId: Schema.String;
2874
+ readonly leaseId: Schema.String;
2875
+ readonly attempt: Schema.Int;
2876
+ readonly fencingToken: Schema.String;
2877
+ readonly capacitySlot: Schema.String;
2878
+ }>;
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;
2660
2885
  }>, Schema.Struct<{
2661
- readonly parts: Schema.$Array<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<{
2662
2899
  readonly url: Schema.String;
2663
2900
  readonly headers: Schema.optionalKey<Schema.$Record<Schema.String, Schema.String>>;
2664
2901
  readonly expiresAt: Schema.String;
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<{
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<{
2914
+ lease: Schema.Struct<{
2915
+ readonly workUnitId: Schema.String;
2916
+ readonly leaseOwnerId: Schema.String;
2917
+ readonly runnerReplicaId: Schema.String;
2918
+ readonly leaseId: Schema.String;
2919
+ readonly attempt: Schema.Int;
2920
+ readonly fencingToken: Schema.String;
2921
+ readonly capacitySlot: Schema.String;
2922
+ }>;
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<{
2672
2926
  lease: Schema.Struct<{
2673
2927
  readonly workUnitId: Schema.String;
2674
2928
  readonly leaseOwnerId: Schema.String;
@@ -2679,29 +2933,17 @@ export declare const RunnerRpcs: RpcGroup.RpcGroup<Rpc.Rpc<"SettledRuns", Schema
2679
2933
  readonly capacitySlot: Schema.String;
2680
2934
  }>;
2681
2935
  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;
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
+ }>;
2702
2944
  }>, Schema.Struct<{
2703
- readonly questionId: Schema.String;
2704
- }>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"StartAgentStep", Schema.Struct<{
2945
+ readonly id: Schema.String;
2946
+ }>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"FinishProgram", Schema.Struct<{
2705
2947
  lease: Schema.Struct<{
2706
2948
  readonly workUnitId: Schema.String;
2707
2949
  readonly leaseOwnerId: Schema.String;
@@ -2711,23 +2953,23 @@ export declare const RunnerRpcs: RpcGroup.RpcGroup<Rpc.Rpc<"SettledRuns", Schema
2711
2953
  readonly fencingToken: Schema.String;
2712
2954
  readonly capacitySlot: Schema.String;
2713
2955
  }>;
2714
- step: Schema.String;
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>;
2726
- }>, Schema.Struct<{
2727
- readonly stepAttemptId: Schema.String;
2728
- }>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"StartVerification", Schema.Struct<{
2729
- lease: Schema.Struct<{
2730
- readonly workUnitId: Schema.String;
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<{
2731
2973
  readonly leaseOwnerId: Schema.String;
2732
2974
  readonly runnerReplicaId: Schema.String;
2733
2975
  readonly leaseId: Schema.String;
@@ -2735,45 +2977,18 @@ export declare const RunnerRpcs: RpcGroup.RpcGroup<Rpc.Rpc<"SettledRuns", Schema
2735
2977
  readonly fencingToken: Schema.String;
2736
2978
  readonly capacitySlot: Schema.String;
2737
2979
  }>;
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<{
2980
+ readonly leaseDurationSeconds: Schema.optionalKey<Schema.Int>;
2981
+ readonly secrets: Schema.optionalKey<Schema.$Array<Schema.Struct<{
2745
2982
  readonly name: Schema.String;
2746
- readonly command: Schema.String;
2747
- readonly workingDirectory: Schema.optionalKey<Schema.String>;
2748
- readonly suggested: Schema.optionalKey<Schema.Boolean>;
2983
+ readonly version: Schema.String;
2749
2984
  }>>>;
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
- }>>;
2774
2985
  }>, Schema.Struct<{
2775
- readonly verificationId: Schema.String;
2776
- }>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"AdmitChild", 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<{
2777
2992
  lease: Schema.Struct<{
2778
2993
  readonly workUnitId: Schema.String;
2779
2994
  readonly leaseOwnerId: Schema.String;
@@ -2783,15 +2998,27 @@ export declare const RunnerRpcs: RpcGroup.RpcGroup<Rpc.Rpc<"SettledRuns", Schema
2783
2998
  readonly fencingToken: Schema.String;
2784
2999
  readonly capacitySlot: Schema.String;
2785
3000
  }>;
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;
3001
+ repoBindingId: Schema.optionalKey<Schema.String>;
2792
3002
  }>, Schema.Struct<{
2793
- readonly runId: Schema.String;
2794
- }>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"StoreArtifact", 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<{
2795
3022
  lease: Schema.Struct<{
2796
3023
  readonly workUnitId: Schema.String;
2797
3024
  readonly leaseOwnerId: Schema.String;
@@ -2802,14 +3029,17 @@ export declare const RunnerRpcs: RpcGroup.RpcGroup<Rpc.Rpc<"SettledRuns", Schema
2802
3029
  readonly capacitySlot: Schema.String;
2803
3030
  }>;
2804
3031
  step: Schema.String;
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>>;
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;
2810
3037
  }>, Schema.Struct<{
2811
- readonly artifactId: Schema.String;
2812
- }>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"AlertTask", Schema.Struct<{
3038
+ readonly status: Schema.Literal<"conflict">;
3039
+ }>, Schema.Struct<{
3040
+ readonly status: Schema.Literal<"moved">;
3041
+ readonly head: Schema.String;
3042
+ }>]>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"OpenChangeRequests", Schema.Struct<{
2813
3043
  lease: Schema.Struct<{
2814
3044
  readonly workUnitId: Schema.String;
2815
3045
  readonly leaseOwnerId: Schema.String;
@@ -2820,20 +3050,18 @@ export declare const RunnerRpcs: RpcGroup.RpcGroup<Rpc.Rpc<"SettledRuns", Schema
2820
3050
  readonly capacitySlot: Schema.String;
2821
3051
  }>;
2822
3052
  step: 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"]>>;
3053
+ authors: Schema.NonEmptyArray<Schema.String>;
2828
3054
  }>, Schema.Struct<{
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;
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;
2835
3063
  }>>;
2836
- }>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"ReadTranscripts", Schema.Struct<{
3064
+ }>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"OwnChangeRequests", Schema.Struct<{
2837
3065
  lease: Schema.Struct<{
2838
3066
  readonly workUnitId: Schema.String;
2839
3067
  readonly leaseOwnerId: Schema.String;
@@ -2844,23 +3072,52 @@ export declare const RunnerRpcs: RpcGroup.RpcGroup<Rpc.Rpc<"SettledRuns", Schema
2844
3072
  readonly capacitySlot: Schema.String;
2845
3073
  }>;
2846
3074
  step: Schema.String;
2847
- days: Schema.Int;
2848
3075
  }>, Schema.Struct<{
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
- }>>;
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;
2862
3083
  }>>;
2863
- }>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"PipelineStatus", Schema.Struct<{
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<{
2864
3121
  lease: Schema.Struct<{
2865
3122
  readonly workUnitId: Schema.String;
2866
3123
  readonly leaseOwnerId: Schema.String;
@@ -2899,7 +3156,7 @@ export declare const RunnerRpcs: RpcGroup.RpcGroup<Rpc.Rpc<"SettledRuns", Schema
2899
3156
  readonly logTail: Schema.optionalKey<Schema.String>;
2900
3157
  }>>;
2901
3158
  }>>;
2902
- }>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"ReportPipeline", Schema.Struct<{
3159
+ }>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"ProgramSecrets", Schema.Struct<{
2903
3160
  lease: Schema.Struct<{
2904
3161
  readonly workUnitId: Schema.String;
2905
3162
  readonly leaseOwnerId: Schema.String;
@@ -2909,13 +3166,7 @@ export declare const RunnerRpcs: RpcGroup.RpcGroup<Rpc.Rpc<"SettledRuns", Schema
2909
3166
  readonly fencingToken: Schema.String;
2910
3167
  readonly capacitySlot: Schema.String;
2911
3168
  }>;
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<{
3169
+ }>, Schema.$Record<Schema.String, Schema.String>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"Propose", Schema.Struct<{
2919
3170
  lease: Schema.Struct<{
2920
3171
  readonly workUnitId: Schema.String;
2921
3172
  readonly leaseOwnerId: Schema.String;
@@ -2926,41 +3177,32 @@ export declare const RunnerRpcs: RpcGroup.RpcGroup<Rpc.Rpc<"SettledRuns", Schema
2926
3177
  readonly capacitySlot: Schema.String;
2927
3178
  }>;
2928
3179
  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;
3180
+ proposal: Schema.Union<readonly [Schema.Struct<{
3181
+ readonly kind: Schema.Literal<"memory">;
3182
+ readonly teamId: Schema.String;
3183
+ readonly content: Schema.String;
3184
+ readonly citations: Schema.NonEmptyArray<Schema.Struct<{
3185
+ readonly runId: Schema.String;
3186
+ readonly stepAttemptId: Schema.String;
3187
+ readonly sequence: Schema.Int;
2939
3188
  }>>;
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;
3189
+ }>, Schema.Struct<{
3190
+ readonly kind: Schema.Literal<"task">;
2956
3191
  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<{
3192
+ readonly description: Schema.String;
3193
+ readonly teamId: Schema.optionalKey<Schema.String>;
3194
+ readonly key: Schema.optionalKey<Schema.String>;
3195
+ readonly citations: Schema.NonEmptyArray<Schema.Struct<{
3196
+ readonly runId: Schema.String;
3197
+ readonly stepAttemptId: Schema.String;
3198
+ readonly sequence: Schema.Int;
3199
+ }>>;
3200
+ }>]>;
3201
+ }>, Schema.Struct<{
3202
+ readonly kind: Schema.Literals<readonly ["memory", "task"]>;
3203
+ readonly id: Schema.String;
3204
+ readonly matched: Schema.optionalKey<Schema.Boolean>;
3205
+ }>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"PublishRelease", Schema.Struct<{
2964
3206
  lease: Schema.Struct<{
2965
3207
  readonly workUnitId: Schema.String;
2966
3208
  readonly leaseOwnerId: Schema.String;
@@ -2971,16 +3213,15 @@ export declare const RunnerRpcs: RpcGroup.RpcGroup<Rpc.Rpc<"SettledRuns", Schema
2971
3213
  readonly capacitySlot: Schema.String;
2972
3214
  }>;
2973
3215
  step: Schema.String;
3216
+ tag: Schema.String;
3217
+ revision: Schema.optionalKey<Schema.String>;
3218
+ title: Schema.String;
3219
+ notes: Schema.String;
2974
3220
  }>, 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<{
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<{
2984
3225
  lease: Schema.Struct<{
2985
3226
  readonly workUnitId: Schema.String;
2986
3227
  readonly leaseOwnerId: Schema.String;
@@ -2991,31 +3232,28 @@ export declare const RunnerRpcs: RpcGroup.RpcGroup<Rpc.Rpc<"SettledRuns", Schema
2991
3232
  readonly capacitySlot: Schema.String;
2992
3233
  }>;
2993
3234
  step: Schema.String;
2994
- proposal: Schema.Union<readonly [Schema.Struct<{
2995
- readonly kind: Schema.Literal<"memory">;
2996
- readonly teamId: Schema.String;
2997
- readonly content: Schema.String;
2998
- readonly citations: Schema.NonEmptyArray<Schema.Struct<{
2999
- readonly runId: Schema.String;
3000
- readonly stepAttemptId: Schema.String;
3001
- readonly sequence: Schema.Int;
3002
- }>>;
3003
- }>, Schema.Struct<{
3004
- readonly kind: Schema.Literal<"task">;
3005
- readonly title: Schema.String;
3006
- readonly description: Schema.String;
3007
- readonly teamId: Schema.optionalKey<Schema.String>;
3008
- readonly key: Schema.optionalKey<Schema.String>;
3009
- readonly citations: Schema.NonEmptyArray<Schema.Struct<{
3010
- readonly runId: Schema.String;
3011
- readonly stepAttemptId: Schema.String;
3012
- readonly sequence: Schema.Int;
3013
- }>>;
3014
- }>]>;
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;
3015
3255
  }>, Schema.Struct<{
3016
- readonly kind: Schema.Literals<readonly ["memory", "task"]>;
3017
- readonly id: Schema.String;
3018
- readonly matched: Schema.optionalKey<Schema.Boolean>;
3256
+ readonly questionId: Schema.String;
3019
3257
  }>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"ReadProject", Schema.Struct<{
3020
3258
  lease: Schema.Struct<{
3021
3259
  readonly workUnitId: Schema.String;
@@ -3055,7 +3293,7 @@ export declare const RunnerRpcs: RpcGroup.RpcGroup<Rpc.Rpc<"SettledRuns", Schema
3055
3293
  readonly change: Schema.String;
3056
3294
  readonly at: Schema.String;
3057
3295
  }>>;
3058
- }>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"DraftUpdate", Schema.Struct<{
3296
+ }>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"ReadTranscripts", Schema.Struct<{
3059
3297
  lease: Schema.Struct<{
3060
3298
  readonly workUnitId: Schema.String;
3061
3299
  readonly leaseOwnerId: Schema.String;
@@ -3066,17 +3304,23 @@ export declare const RunnerRpcs: RpcGroup.RpcGroup<Rpc.Rpc<"SettledRuns", Schema
3066
3304
  readonly capacitySlot: Schema.String;
3067
3305
  }>;
3068
3306
  step: 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>;
3076
- }>;
3307
+ days: Schema.Int;
3077
3308
  }>, Schema.Struct<{
3078
- readonly id: Schema.String;
3079
- }>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"IntegrationBranch", 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<{
3080
3324
  lease: Schema.Struct<{
3081
3325
  readonly workUnitId: Schema.String;
3082
3326
  readonly leaseOwnerId: Schema.String;
@@ -3086,12 +3330,10 @@ export declare const RunnerRpcs: RpcGroup.RpcGroup<Rpc.Rpc<"SettledRuns", Schema
3086
3330
  readonly fencingToken: Schema.String;
3087
3331
  readonly capacitySlot: Schema.String;
3088
3332
  }>;
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<{
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<{
3095
3337
  lease: Schema.Struct<{
3096
3338
  readonly workUnitId: Schema.String;
3097
3339
  readonly leaseOwnerId: Schema.String;
@@ -3102,13 +3344,24 @@ export declare const RunnerRpcs: RpcGroup.RpcGroup<Rpc.Rpc<"SettledRuns", Schema
3102
3344
  readonly capacitySlot: Schema.String;
3103
3345
  }>;
3104
3346
  step: Schema.String;
3105
- number: Schema.String;
3106
- head: Schema.String;
3107
- note: Schema.String;
3108
- }>, 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<{
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<{
3112
3365
  lease: Schema.Struct<{
3113
3366
  readonly workUnitId: Schema.String;
3114
3367
  readonly leaseOwnerId: Schema.String;
@@ -3119,13 +3372,16 @@ export declare const RunnerRpcs: RpcGroup.RpcGroup<Rpc.Rpc<"SettledRuns", Schema
3119
3372
  readonly capacitySlot: Schema.String;
3120
3373
  }>;
3121
3374
  step: Schema.String;
3122
- changeRequestId: Schema.optionalKey<Schema.String>;
3123
- ref: Schema.optionalKey<Schema.String>;
3124
- all: Schema.optionalKey<Schema.Boolean>;
3375
+ changeRequestId: Schema.String;
3376
+ verification: Schema.String;
3125
3377
  }>, Schema.Struct<{
3126
3378
  readonly head: Schema.String;
3127
- readonly pipelines: Schema.Int;
3128
- }>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"PublishRelease", Schema.Struct<{
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<{
3129
3385
  lease: Schema.Struct<{
3130
3386
  readonly workUnitId: Schema.String;
3131
3387
  readonly leaseOwnerId: Schema.String;
@@ -3136,15 +3392,13 @@ export declare const RunnerRpcs: RpcGroup.RpcGroup<Rpc.Rpc<"SettledRuns", Schema
3136
3392
  readonly capacitySlot: Schema.String;
3137
3393
  }>;
3138
3394
  step: Schema.String;
3139
- tag: Schema.String;
3140
- revision: Schema.optionalKey<Schema.String>;
3141
- title: Schema.String;
3142
- notes: Schema.String;
3395
+ changeRequestId: Schema.optionalKey<Schema.String>;
3396
+ ref: Schema.optionalKey<Schema.String>;
3397
+ all: Schema.optionalKey<Schema.Boolean>;
3143
3398
  }>, 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<{
3399
+ readonly head: Schema.String;
3400
+ readonly pipelines: Schema.Int;
3401
+ }>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"ResumeCheckpoint", Schema.Struct<{
3148
3402
  lease: Schema.Struct<{
3149
3403
  readonly workUnitId: Schema.String;
3150
3404
  readonly leaseOwnerId: Schema.String;
@@ -3154,41 +3408,17 @@ export declare const RunnerRpcs: RpcGroup.RpcGroup<Rpc.Rpc<"SettledRuns", Schema
3154
3408
  readonly fencingToken: Schema.String;
3155
3409
  readonly capacitySlot: Schema.String;
3156
3410
  }>;
3157
- step: Schema.String;
3158
- name: Schema.String;
3159
- caption: Schema.optional<Schema.String>;
3160
- contentType: Schema.String;
3161
- byteSize: Schema.Int;
3162
- sha256: Schema.String;
3163
- }>, Schema.Struct<{
3164
- readonly file: Schema.Struct<{
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;
3165
3416
  readonly id: Schema.String;
3166
- readonly runId: Schema.String;
3167
- readonly step: Schema.String;
3168
3417
  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
3418
  readonly url: Schema.String;
3178
3419
  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;
3189
- }>>;
3190
- }>]>>;
3191
- }>, Schema.Union<readonly [typeof RunnerRpcError, typeof RunFileRefused]>, typeof RunnerAuthentication, never> | Rpc.Rpc<"RunFileParts", Schema.Struct<{
3420
+ }>>;
3421
+ }>>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"ReviewThreads", Schema.Struct<{
3192
3422
  lease: Schema.Struct<{
3193
3423
  readonly workUnitId: Schema.String;
3194
3424
  readonly leaseOwnerId: Schema.String;
@@ -3198,16 +3428,20 @@ export declare const RunnerRpcs: RpcGroup.RpcGroup<Rpc.Rpc<"SettledRuns", Schema
3198
3428
  readonly fencingToken: Schema.String;
3199
3429
  readonly capacitySlot: Schema.String;
3200
3430
  }>;
3201
- fileId: Schema.String;
3202
- partNumbers: Schema.$Array<Schema.Int>;
3431
+ step: Schema.String;
3432
+ changeRequestId: Schema.String;
3203
3433
  }>, Schema.Struct<{
3204
- readonly parts: Schema.$Array<Schema.Struct<{
3205
- readonly url: Schema.String;
3206
- readonly headers: Schema.optionalKey<Schema.$Record<Schema.String, Schema.String>>;
3207
- readonly expiresAt: Schema.String;
3208
- readonly partNumber: Schema.Int;
3434
+ readonly threads: Schema.$Array<Schema.Struct<{
3435
+ 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;
3442
+ }>>;
3209
3443
  }>>;
3210
- }>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"ResumeCheckpoint", Schema.Struct<{
3444
+ }>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"RunFileParts", Schema.Struct<{
3211
3445
  lease: Schema.Struct<{
3212
3446
  readonly workUnitId: Schema.String;
3213
3447
  readonly leaseOwnerId: Schema.String;
@@ -3217,22 +3451,16 @@ export declare const RunnerRpcs: RpcGroup.RpcGroup<Rpc.Rpc<"SettledRuns", Schema
3217
3451
  readonly fencingToken: Schema.String;
3218
3452
  readonly capacitySlot: Schema.String;
3219
3453
  }>;
3220
- }>, Schema.UndefinedOr<Schema.Struct<{
3221
- readonly ref: Schema.optionalKey<Schema.String>;
3222
- readonly revision: Schema.optionalKey<Schema.String>;
3223
- readonly session: Schema.optionalKey<Schema.Struct<{
3224
- readonly harness: Schema.String;
3225
- readonly id: Schema.String;
3226
- readonly name: Schema.String;
3454
+ fileId: Schema.String;
3455
+ partNumbers: Schema.$Array<Schema.Int>;
3456
+ }>, Schema.Struct<{
3457
+ readonly parts: Schema.$Array<Schema.Struct<{
3227
3458
  readonly url: Schema.String;
3228
3459
  readonly headers: Schema.optionalKey<Schema.$Record<Schema.String, Schema.String>>;
3460
+ readonly expiresAt: Schema.String;
3461
+ readonly partNumber: Schema.Int;
3229
3462
  }>>;
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<{
3463
+ }>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"SaveCheckpoint", Schema.Struct<{
3236
3464
  lease: Schema.Struct<{
3237
3465
  readonly workUnitId: Schema.String;
3238
3466
  readonly leaseOwnerId: Schema.String;
@@ -3242,55 +3470,17 @@ export declare const RunnerRpcs: RpcGroup.RpcGroup<Rpc.Rpc<"SettledRuns", Schema
3242
3470
  readonly fencingToken: Schema.String;
3243
3471
  readonly capacitySlot: Schema.String;
3244
3472
  }>;
3245
- step: 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;
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
+ }>>;
3280
3482
  }>;
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<{
3483
+ }>, Schema.Void, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"ScheduleClock", Schema.Struct<{
3294
3484
  lease: Schema.Struct<{
3295
3485
  readonly workUnitId: Schema.String;
3296
3486
  readonly leaseOwnerId: Schema.String;
@@ -3300,62 +3490,45 @@ export declare const RunnerRpcs: RpcGroup.RpcGroup<Rpc.Rpc<"SettledRuns", Schema
3300
3490
  readonly fencingToken: Schema.String;
3301
3491
  readonly capacitySlot: Schema.String;
3302
3492
  }>;
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
- }>]>;
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;
3498
+ readonly ref: Schema.optionalKey<Schema.String>;
3499
+ readonly repoBinding: Schema.optionalKey<Schema.Struct<{
3500
+ 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
+ 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>;
3357
3510
  }>>;
3358
- }>, Schema.Void, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"AwaitEvent", Schema.Struct<{
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<{
3359
3532
  lease: Schema.Struct<{
3360
3533
  readonly workUnitId: Schema.String;
3361
3534
  readonly leaseOwnerId: Schema.String;
@@ -3367,19 +3540,19 @@ export declare const RunnerRpcs: RpcGroup.RpcGroup<Rpc.Rpc<"SettledRuns", Schema
3367
3540
  }>;
3368
3541
  step: Schema.String;
3369
3542
  deferredName: Schema.String;
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>;
3381
- }>>>;
3382
- }>, Schema.Void, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"ClaimResource", Schema.Struct<{
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<{
3383
3556
  lease: Schema.Struct<{
3384
3557
  readonly workUnitId: Schema.String;
3385
3558
  readonly leaseOwnerId: Schema.String;
@@ -3391,169 +3564,43 @@ export declare const RunnerRpcs: RpcGroup.RpcGroup<Rpc.Rpc<"SettledRuns", Schema
3391
3564
  }>;
3392
3565
  step: Schema.String;
3393
3566
  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">;
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>;
3576
+ }>>>;
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<{
3413
3588
  readonly name: Schema.String;
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>;
3426
- }>>;
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;
3589
+ readonly direction: Schema.Literals<readonly ["lower", "higher"]>;
3590
+ readonly role: Schema.Literals<readonly ["primary", "guardrail"]>;
3591
+ readonly lowVariance: Schema.optionalKey<Schema.Boolean>;
3490
3592
  }>>;
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<{
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<{
3557
3604
  lease: Schema.Struct<{
3558
3605
  readonly workUnitId: Schema.String;
3559
3606
  readonly leaseOwnerId: Schema.String;
@@ -3564,61 +3611,14 @@ export declare const RunnerRpcs: RpcGroup.RpcGroup<Rpc.Rpc<"SettledRuns", Schema
3564
3611
  readonly capacitySlot: Schema.String;
3565
3612
  }>;
3566
3613
  step: Schema.String;
3614
+ kind: Schema.String;
3615
+ title: Schema.String;
3567
3616
  text: Schema.String;
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<{
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<{
3622
3622
  lease: Schema.Struct<{
3623
3623
  readonly workUnitId: Schema.String;
3624
3624
  readonly leaseOwnerId: Schema.String;