@kitman-sh/sdk 0.10.68 → 0.10.70

package/dist/build/index.js

@@ -4,7 +4,7 @@ import {
   KitDigest,
   AgentDeclaration,
   KitDeclarations
-} from "../chunk-dnmb9dw9.js";
+} from "../chunk-kjkn6d60.js";
 import {
   digestSha256,
   digestSha512,
@@ -13,7 +13,7 @@ import {
   RunnerRpcProtocolVersion,
   describeFlag2,
   Described2
-} from "../chunk-x37rn3aw.js";
+} from "../chunk-5qeam2w1.js";
 
 // packages/core/src/json.ts
 import * as Schema from "effect/Schema";

package/dist/{chunk-x37rn3aw.js → chunk-5qeam2w1.js}

@@ -33,7 +33,7 @@ import {
   executeLoop2,
   LoopCheckError2,
   checkLoop2
-} from "./chunk-dnmb9dw9.js";
+} from "./chunk-kjkn6d60.js";
 // packages/core/src/agent-environment.ts
 import * as Schema from "effect/Schema";
 var AgentEnvironmentPolicy = Schema.Union([Schema.Literal("recommended"), Schema.Literal("required")]);
@@ -909,6 +909,7 @@ class RunnerCapabilityRpcs extends RpcGroup.make(Rpc.make("PutQuestion", {
     revision: Schema7.optionalKey(Schema7.String),
     checks: Schema7.optional(Schema7.Array(Schema7.String)),
     suggested: Schema7.optionalKey(Schema7.Array(ApprovedCheck)),
+    rerunFailed: Schema7.optionalKey(Schema7.Boolean),
     measure: Schema7.optionalKey(Schema7.Struct({
       base: Schema7.optionalKey(Schema7.String),
       plan: MeasurePlan2,
@@ -1050,7 +1051,19 @@ class RunnerCapabilityRpcs extends RpcGroup.make(Rpc.make("PutQuestion", {
       logTail: Schema7.optionalKey(Schema7.String)
     })),
     readAt: Schema7.optionalKey(Schema7.String),
-    runnerChecks: Schema7.optionalKey(Schema7.Array(Schema7.String))
+    runnerChecks: Schema7.optionalKey(Schema7.Array(Schema7.String)),
+    approved: Schema7.optionalKey(Schema7.String),
+    repository: Schema7.optionalKey(Schema7.String),
+    target: Schema7.optionalKey(Schema7.Struct({
+      branch: Schema7.String,
+      head: Schema7.String,
+      jobs: Schema7.Array(Schema7.Struct({
+        name: Schema7.String,
+        status: Schema7.Literals(["running", "success", "failed", "skipped"]),
+        url: Schema7.optionalKey(Schema7.String),
+        logTail: Schema7.optionalKey(Schema7.String)
+      }))
+    }))
   }),
   error: RunnerRpcError
 }), Rpc.make("ReportPipeline", {
@@ -1402,6 +1415,7 @@ var runnerHost = (capabilities) => ({
     ...launch.revision === undefined ? undefined : { revision: launch.revision },
     ...launch.checks === undefined ? undefined : { checks: launch.checks },
     ...launch.suggested === undefined ? undefined : { suggested: launch.suggested },
+    ...launch.rerunFailed === undefined ? undefined : { rerunFailed: launch.rerunFailed },
     ...launch.measure === undefined ? undefined : { measure: launch.measure }
   })).pipe(Effect2.asVoid),
   startAgentWork: (launch) => requested2(launch.step, capabilities.startAgentStep({
@@ -1625,6 +1639,7 @@ var rpcProgramPorts2 = (rpc, work) => {
       ...verification.revision === undefined ? undefined : { revision: verification.revision },
       ...verification.checks === undefined ? undefined : { checks: [...verification.checks] },
       ...verification.suggested === undefined ? undefined : { suggested: [...verification.suggested] },
+      ...verification.rerunFailed === undefined ? undefined : { rerunFailed: verification.rerunFailed },
       ...verification.measure === undefined ? undefined : { measure: verification.measure }
     }),
     startAgentStep: ({ secrets, ...step }) => rpc.startAgentStep({ lease, ...step, ...secrets === undefined ? undefined : { secrets: [...secrets] } }),

package/dist/{chunk-dnmb9dw9.js → chunk-kjkn6d60.js}

@@ -1861,6 +1861,12 @@ var RunWaiting = Schema12.Union([
     name: Schema12.String.check(Schema12.isMinLength(1)),
     verificationId: Id
   }),
+  Schema12.Struct({
+    kind: Schema12.Literal("claim"),
+    name: Schema12.String.check(Schema12.isMinLength(1)),
+    resource: Schema12.String.check(Schema12.isMinLength(1)),
+    holder: Schema12.optionalKey(Schema12.Struct({ runId: Id, loopId: Schema12.String }))
+  }),
   Schema12.Struct({
     kind: Schema12.Literal("queue"),
     name: Schema12.String.check(Schema12.isMinLength(1)),
@@ -3034,6 +3040,7 @@ var verify2 = (name, request) => takeStep2(name, "verify", "verify", Effect3.gen
     ...request.revision === undefined ? undefined : { revision: request.revision },
     ...request.checks === undefined ? undefined : { checks: request.checks },
     ...request.suggested === undefined || request.suggested.length === 0 ? undefined : { suggested: request.suggested },
+    ...request.rerunFailed === true ? { rerunFailed: true } : undefined,
     token
   }));
   return yield* DurableDeferred.await(deferred);
@@ -3242,7 +3249,10 @@ var PipelineStatus2 = Schema19.Struct({
   source: Schema19.Literals(["forge", "reported"]),
   jobs: Schema19.Array(PipelineJob2),
   readAt: Schema19.optionalKey(Schema19.String),
-  runnerChecks: Schema19.optionalKey(Schema19.Array(Schema19.String))
+  runnerChecks: Schema19.optionalKey(Schema19.Array(Schema19.String)),
+  approved: Schema19.optionalKey(Schema19.String),
+  repository: Schema19.optionalKey(Schema19.String),
+  target: Schema19.optionalKey(Schema19.Struct({ branch: Schema19.String, head: Schema19.String, jobs: Schema19.Array(PipelineJob2) }))
 });
 var ReviewThread2 = Schema19.Struct({
   id: Schema19.String,
@@ -4129,7 +4139,7 @@ var journaled = (engine, journal, ran) => ({
   })
 });
 var scriptedExit = (scripted, failure) => scripted === undefined ? Exit3.fail(failure("nothing was scripted for this Step")) : scripted instanceof ScriptedFailure2 ? Exit3.fail(failure(scripted.reason)) : Exit3.succeed(scripted);
-var scriptedHost = (script, engine, agentLaunches, childLaunches, waits) => {
+var scriptedHost = (script, engine, agentLaunches, childLaunches, waits, verifyLaunches) => {
   const resolve = (deferred, token, exit) => DurableDeferred4.done(deferred, { token, exit }).pipe(Effect8.provideService(WorkflowEngine.WorkflowEngine, engine));
   return {
     startAgentWork: (launch) => Effect8.andThen(Effect8.sync(() => agentLaunches.push({
@@ -4156,9 +4166,16 @@ var scriptedHost = (script, engine, agentLaunches, childLaunches, waits) => {
       });
       return resolve(eventDeferred2(launch.step), launch.token, event === undefined ? Exit3.fail(new WaitTimedOut2({ step: launch.step, event: launch.event })) : Exit3.succeed(event));
     },
-    claimResource: (launch) => launch.action === "let_go" ? resolve(letGoDeferred2(launch.step), launch.token, Exit3.succeed(null)) : resolve(claimDeferred2(launch.step), launch.token, Exit3.succeed(script.claims?.[launch.step] ?? { status: "granted", resource: launch.resource })),
+    claimResource: (launch) => Effect8.flatMap(script.claimed?.({ step: launch.step, resource: launch.resource, action: launch.action }) ?? Effect8.undefined, (settled) => launch.action === "let_go" ? resolve(letGoDeferred2(launch.step), launch.token, Exit3.succeed(null)) : resolve(claimDeferred2(launch.step), launch.token, Exit3.succeed(settled ?? script.claims?.[launch.step] ?? { status: "granted", resource: launch.resource }))),
     startVerification: (launch) => {
       const scripted = script.verifications?.[launch.step];
+      if (launch.measure === undefined)
+        verifyLaunches.push({
+          step: launch.step,
+          ...launch.revision === undefined ? undefined : { revision: launch.revision },
+          ...launch.checks === undefined ? undefined : { checks: launch.checks },
+          ...launch.rerunFailed === undefined ? undefined : { rerunFailed: launch.rerunFailed }
+        });
       if (launch.measure !== undefined) {
         const measured = script.measurements?.[launch.step];
         const flat = Array.from({ length: launch.measure.samples }, () => Object.fromEntries(launch.measure?.plan.metrics.map((metric) => [metric.name, 100]) ?? []));
@@ -4209,6 +4226,7 @@ var testLoop2 = (loop, script) => {
   const agentLaunches = [];
   const childLaunches = [];
   const waits = [];
+  const verifyLaunches = [];
   let latestSteps = [];
   const declared = capabilitiesOf2(loop);
   const granted = new Set((script.grant ?? declared).filter((capability) => declared.includes(capability)));
@@ -4221,7 +4239,7 @@ var testLoop2 = (loop, script) => {
   const execute = (payload) => Effect8.gen(function* () {
     const engine = yield* WorkflowEngine.WorkflowEngine;
     return yield* executeLoop2(loop, {
-      host: scriptedHost(script, engine, agentLaunches, childLaunches, waits),
+      host: scriptedHost(script, engine, agentLaunches, childLaunches, waits, verifyLaunches),
       activities,
       granted,
       onRun: (run) => {
@@ -4231,7 +4249,7 @@ var testLoop2 = (loop, script) => {
   });
   return Effect8.gen(function* () {
     const result = yield* Effect8.exit(workflow.execute({ input: script.input }).pipe(Effect8.provideService(ConfigProvider.ConfigProvider, ConfigProvider.fromUnknown(script.secrets ?? {}))));
-    return { result, steps: latestSteps, journal, activities: ran, agentLaunches, childLaunches, waits };
+    return { result, steps: latestSteps, journal, activities: ran, agentLaunches, childLaunches, waits, verifyLaunches };
   }).pipe(Effect8.provide(workflow.toLayer(execute).pipe(Layer.provideMerge(WorkflowEngine.layerMemory))));
 };
 // packages/sdk/src/loop/review.ts

package/dist/loop/index.js

@@ -173,7 +173,7 @@ import {
   syncBase2,
   Continuing2,
   continuingBrief2
-} from "../chunk-dnmb9dw9.js";
+} from "../chunk-kjkn6d60.js";
 export {
   AlertTaskActivity2 as AlertTaskActivity,
   AlertTaskRequest2 as AlertTaskRequest,

package/dist/program/index.js

@@ -1,5 +1,5 @@
 // @bun
-import"../chunk-dnmb9dw9.js";
+import"../chunk-kjkn6d60.js";
 import {
   JournalWriteFailed2,
   refusedStep2,
@@ -17,7 +17,7 @@ import {
   networkGuard2,
   carriedKits2,
   runKit2
-} from "../chunk-x37rn3aw.js";
+} from "../chunk-5qeam2w1.js";
 export {
   Described2 as Described,
   JournalWriteFailed2 as JournalWriteFailed,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kitman-sh/sdk",
-  "version": "0.10.68",
+  "version": "0.10.70",
   "type": "module",
   "license": "UNLICENSED",
   "exports": {

package/types/packages/core/src/change-request-review.d.ts

@@ -301,6 +301,14 @@ export declare const RunChangesRequested: Schema.Struct<{
                 readonly kind: Schema.Literal<"verification">;
                 readonly name: Schema.String;
                 readonly verificationId: Schema.String;
+            }>, Schema.Struct<{
+                readonly kind: Schema.Literal<"claim">;
+                readonly name: Schema.String;
+                readonly resource: Schema.String;
+                readonly holder: Schema.optionalKey<Schema.Struct<{
+                    readonly runId: Schema.String;
+                    readonly loopId: Schema.String;
+                }>>;
             }>, Schema.Struct<{
                 readonly kind: Schema.Literal<"queue">;
                 readonly name: Schema.String;

package/types/packages/core/src/loop.d.ts

@@ -1154,6 +1154,14 @@ export declare const RunWaiting: Schema.Union<readonly [Schema.Struct<{
     readonly kind: Schema.Literal<"verification">;
     readonly name: Schema.String;
     readonly verificationId: Schema.String;
+}>, Schema.Struct<{
+    readonly kind: Schema.Literal<"claim">;
+    readonly name: Schema.String;
+    readonly resource: Schema.String;
+    readonly holder: Schema.optionalKey<Schema.Struct<{
+        readonly runId: Schema.String;
+        readonly loopId: Schema.String;
+    }>>;
 }>, Schema.Struct<{
     readonly kind: Schema.Literal<"queue">;
     readonly name: Schema.String;
@@ -1385,6 +1393,14 @@ export declare const Run: Schema.Struct<{
         readonly kind: Schema.Literal<"verification">;
         readonly name: Schema.String;
         readonly verificationId: Schema.String;
+    }>, Schema.Struct<{
+        readonly kind: Schema.Literal<"claim">;
+        readonly name: Schema.String;
+        readonly resource: Schema.String;
+        readonly holder: Schema.optionalKey<Schema.Struct<{
+            readonly runId: Schema.String;
+            readonly loopId: Schema.String;
+        }>>;
     }>, Schema.Struct<{
         readonly kind: Schema.Literal<"queue">;
         readonly name: Schema.String;
@@ -2177,6 +2193,14 @@ export declare const RunStarted: Schema.Struct<{
             readonly kind: Schema.Literal<"verification">;
             readonly name: Schema.String;
             readonly verificationId: Schema.String;
+        }>, Schema.Struct<{
+            readonly kind: Schema.Literal<"claim">;
+            readonly name: Schema.String;
+            readonly resource: Schema.String;
+            readonly holder: Schema.optionalKey<Schema.Struct<{
+                readonly runId: Schema.String;
+                readonly loopId: Schema.String;
+            }>>;
         }>, Schema.Struct<{
             readonly kind: Schema.Literal<"queue">;
             readonly name: Schema.String;
@@ -2519,6 +2543,14 @@ export declare const RunShow: Schema.Struct<{
             readonly kind: Schema.Literal<"verification">;
             readonly name: Schema.String;
             readonly verificationId: Schema.String;
+        }>, Schema.Struct<{
+            readonly kind: Schema.Literal<"claim">;
+            readonly name: Schema.String;
+            readonly resource: Schema.String;
+            readonly holder: Schema.optionalKey<Schema.Struct<{
+                readonly runId: Schema.String;
+                readonly loopId: Schema.String;
+            }>>;
         }>, Schema.Struct<{
             readonly kind: Schema.Literal<"queue">;
             readonly name: Schema.String;
@@ -2774,6 +2806,14 @@ export declare const RunShow: Schema.Struct<{
         readonly kind: Schema.Literal<"verification">;
         readonly name: Schema.String;
         readonly verificationId: Schema.String;
+    }>, Schema.Struct<{
+        readonly kind: Schema.Literal<"claim">;
+        readonly name: Schema.String;
+        readonly resource: Schema.String;
+        readonly holder: Schema.optionalKey<Schema.Struct<{
+            readonly runId: Schema.String;
+            readonly loopId: Schema.String;
+        }>>;
     }>, Schema.Struct<{
         readonly kind: Schema.Literal<"queue">;
         readonly name: Schema.String;
@@ -3102,6 +3142,14 @@ export declare const RunListItem: Schema.Struct<{
             readonly kind: Schema.Literal<"verification">;
             readonly name: Schema.String;
             readonly verificationId: Schema.String;
+        }>, Schema.Struct<{
+            readonly kind: Schema.Literal<"claim">;
+            readonly name: Schema.String;
+            readonly resource: Schema.String;
+            readonly holder: Schema.optionalKey<Schema.Struct<{
+                readonly runId: Schema.String;
+                readonly loopId: Schema.String;
+            }>>;
         }>, Schema.Struct<{
             readonly kind: Schema.Literal<"queue">;
             readonly name: Schema.String;
@@ -3274,6 +3322,14 @@ export declare const RunList: Schema.Struct<{
                 readonly kind: Schema.Literal<"verification">;
                 readonly name: Schema.String;
                 readonly verificationId: Schema.String;
+            }>, Schema.Struct<{
+                readonly kind: Schema.Literal<"claim">;
+                readonly name: Schema.String;
+                readonly resource: Schema.String;
+                readonly holder: Schema.optionalKey<Schema.Struct<{
+                    readonly runId: Schema.String;
+                    readonly loopId: Schema.String;
+                }>>;
             }>, Schema.Struct<{
                 readonly kind: Schema.Literal<"queue">;
                 readonly name: Schema.String;
@@ -3452,6 +3508,14 @@ export declare const RunWaitResult: Schema.Struct<{
             readonly kind: Schema.Literal<"verification">;
             readonly name: Schema.String;
             readonly verificationId: Schema.String;
+        }>, Schema.Struct<{
+            readonly kind: Schema.Literal<"claim">;
+            readonly name: Schema.String;
+            readonly resource: Schema.String;
+            readonly holder: Schema.optionalKey<Schema.Struct<{
+                readonly runId: Schema.String;
+                readonly loopId: Schema.String;
+            }>>;
         }>, Schema.Struct<{
             readonly kind: Schema.Literal<"queue">;
             readonly name: Schema.String;
@@ -3674,6 +3738,14 @@ export declare const RunActionTaken: Schema.Struct<{
             readonly kind: Schema.Literal<"verification">;
             readonly name: Schema.String;
             readonly verificationId: Schema.String;
+        }>, Schema.Struct<{
+            readonly kind: Schema.Literal<"claim">;
+            readonly name: Schema.String;
+            readonly resource: Schema.String;
+            readonly holder: Schema.optionalKey<Schema.Struct<{
+                readonly runId: Schema.String;
+                readonly loopId: Schema.String;
+            }>>;
         }>, Schema.Struct<{
             readonly kind: Schema.Literal<"queue">;
             readonly name: Schema.String;

package/types/packages/core/src/my-teams.d.ts

@@ -144,6 +144,14 @@ declare const MyTeamsRun: Schema.Struct<{
         readonly kind: Schema.Literal<"verification">;
         readonly name: Schema.String;
         readonly verificationId: Schema.String;
+    }>, Schema.Struct<{
+        readonly kind: Schema.Literal<"claim">;
+        readonly name: Schema.String;
+        readonly resource: Schema.String;
+        readonly holder: Schema.optionalKey<Schema.Struct<{
+            readonly runId: Schema.String;
+            readonly loopId: Schema.String;
+        }>>;
     }>, Schema.Struct<{
         readonly kind: Schema.Literal<"queue">;
         readonly name: Schema.String;
@@ -311,6 +319,14 @@ export declare const MyTeamsCard: Schema.Struct<{
             readonly kind: Schema.Literal<"verification">;
             readonly name: Schema.String;
             readonly verificationId: Schema.String;
+        }>, Schema.Struct<{
+            readonly kind: Schema.Literal<"claim">;
+            readonly name: Schema.String;
+            readonly resource: Schema.String;
+            readonly holder: Schema.optionalKey<Schema.Struct<{
+                readonly runId: Schema.String;
+                readonly loopId: Schema.String;
+            }>>;
         }>, Schema.Struct<{
             readonly kind: Schema.Literal<"queue">;
             readonly name: Schema.String;
@@ -530,6 +546,14 @@ export declare const MyTeams: Schema.Struct<{
                 readonly kind: Schema.Literal<"verification">;
                 readonly name: Schema.String;
                 readonly verificationId: Schema.String;
+            }>, Schema.Struct<{
+                readonly kind: Schema.Literal<"claim">;
+                readonly name: Schema.String;
+                readonly resource: Schema.String;
+                readonly holder: Schema.optionalKey<Schema.Struct<{
+                    readonly runId: Schema.String;
+                    readonly loopId: Schema.String;
+                }>>;
             }>, Schema.Struct<{
                 readonly kind: Schema.Literal<"queue">;
                 readonly name: Schema.String;
@@ -747,6 +771,14 @@ export declare const MyTeams: Schema.Struct<{
                 readonly kind: Schema.Literal<"verification">;
                 readonly name: Schema.String;
                 readonly verificationId: Schema.String;
+            }>, Schema.Struct<{
+                readonly kind: Schema.Literal<"claim">;
+                readonly name: Schema.String;
+                readonly resource: Schema.String;
+                readonly holder: Schema.optionalKey<Schema.Struct<{
+                    readonly runId: Schema.String;
+                    readonly loopId: Schema.String;
+                }>>;
             }>, Schema.Struct<{
                 readonly kind: Schema.Literal<"queue">;
                 readonly name: Schema.String;
@@ -964,6 +996,14 @@ export declare const MyTeams: Schema.Struct<{
                 readonly kind: Schema.Literal<"verification">;
                 readonly name: Schema.String;
                 readonly verificationId: Schema.String;
+            }>, Schema.Struct<{
+                readonly kind: Schema.Literal<"claim">;
+                readonly name: Schema.String;
+                readonly resource: Schema.String;
+                readonly holder: Schema.optionalKey<Schema.Struct<{
+                    readonly runId: Schema.String;
+                    readonly loopId: Schema.String;
+                }>>;
             }>, Schema.Struct<{
                 readonly kind: Schema.Literal<"queue">;
                 readonly name: Schema.String;
@@ -1181,6 +1221,14 @@ export declare const MyTeams: Schema.Struct<{
                 readonly kind: Schema.Literal<"verification">;
                 readonly name: Schema.String;
                 readonly verificationId: Schema.String;
+            }>, Schema.Struct<{
+                readonly kind: Schema.Literal<"claim">;
+                readonly name: Schema.String;
+                readonly resource: Schema.String;
+                readonly holder: Schema.optionalKey<Schema.Struct<{
+                    readonly runId: Schema.String;
+                    readonly loopId: Schema.String;
+                }>>;
             }>, Schema.Struct<{
                 readonly kind: Schema.Literal<"queue">;
                 readonly name: Schema.String;
@@ -1382,6 +1430,14 @@ export declare const TaskRuns: Schema.Struct<{
                 readonly kind: Schema.Literal<"verification">;
                 readonly name: Schema.String;
                 readonly verificationId: Schema.String;
+            }>, Schema.Struct<{
+                readonly kind: Schema.Literal<"claim">;
+                readonly name: Schema.String;
+                readonly resource: Schema.String;
+                readonly holder: Schema.optionalKey<Schema.Struct<{
+                    readonly runId: Schema.String;
+                    readonly loopId: Schema.String;
+                }>>;
             }>, Schema.Struct<{
                 readonly kind: Schema.Literal<"queue">;
                 readonly name: Schema.String;

package/types/packages/core/src/run-display.d.ts

@@ -1,4 +1,4 @@
-import type { Run, RunDisplay, RunDisplayState, RunShow } from './loop';
+import type { Run, RunDisplay, RunDisplayState, RunShow, RunWaiting } from './loop';
 export type RunDisplayInput = Pick<RunShow, 'run' | 'steps' | 'questions' | 'children' | 'waiting'> & {
     /** A Runner has leased one of the Run's orchestration Work Units. */
     readonly claimed: boolean;
@@ -8,6 +8,10 @@ export type RunDisplayInput = Pick<RunShow, 'run' | 'steps' | 'questions' | 'chi
     readonly failedChecks: readonly string[];
 };
 export declare const runDisplayLabels: Record<RunDisplayState, string>;
+/** A resource the Run waits its turn for, and who holds it. */
+export declare const turnWords: (entry: Extract<RunWaiting, {
+    readonly kind: 'claim';
+}>) => string;
 /** What a Run's output says it left open: any Loop's `unsettled` list. `displayFacts` in run-list.ts reads the same. */
 export declare const reportedUnsettled: (output: Run['output']) => readonly string[] | undefined;
 /** What a Run and the Child Runs below it report left open. */

package/types/packages/live/src/rpc/runner-client.d.ts

@@ -1219,6 +1219,7 @@ export declare const makeProgramRpcClient: (options: ConnectionOptions) => Effec
             readonly workingDirectory?: string;
             readonly suggested?: boolean;
         }[];
+        readonly rerunFailed?: boolean;
         readonly measure?: {
             readonly base?: string;
             readonly plan: {
@@ -1709,6 +1710,18 @@ export declare const makeProgramRpcClient: (options: ConnectionOptions) => Effec
         }[];
         readonly readAt?: string;
         readonly runnerChecks?: readonly string[];
+        readonly approved?: string;
+        readonly repository?: string;
+        readonly target?: {
+            readonly branch: string;
+            readonly head: string;
+            readonly jobs: readonly {
+                readonly name: string;
+                readonly status: "failed" | "running" | "skipped" | "success";
+                readonly url?: string;
+                readonly logTail?: string;
+            }[];
+        };
     }, import("effect/rpc/RpcClientError").RpcClientError | import("./runner-group").RunnerRpcError | (Discard extends true ? never : import("./runner-group").RunnerRpcError), never>>[0]) => Effect.Effect<{
         readonly head: string;
         readonly status: "canceled" | "failed" | "none" | "running" | "success";
@@ -1721,6 +1734,18 @@ export declare const makeProgramRpcClient: (options: ConnectionOptions) => Effec
         }[];
         readonly readAt?: string;
         readonly runnerChecks?: readonly string[];
+        readonly approved?: string;
+        readonly repository?: string;
+        readonly target?: {
+            readonly branch: string;
+            readonly head: string;
+            readonly jobs: readonly {
+                readonly name: string;
+                readonly status: "failed" | "running" | "skipped" | "success";
+                readonly url?: string;
+                readonly logTail?: string;
+            }[];
+        };
     }, Error | import("effect/rpc/RpcClientError").RpcClientError | import("./runner-group").RunnerRpcError, never>;
     reportPipeline: (input: Parameters<<const AsQueue extends boolean = false, const Discard = false>(input: {
         readonly lease: {

package/types/packages/live/src/rpc/runner-group.d.ts

@@ -1023,6 +1023,18 @@ declare const RunnerCapabilityRpcs_base: RpcGroup.RpcGroup<Rpc.Rpc<"AdmitChild",
     }>>;
     readonly readAt: Schema.optionalKey<Schema.String>;
     readonly runnerChecks: Schema.optionalKey<Schema.$Array<Schema.String>>;
+    readonly approved: Schema.optionalKey<Schema.String>;
+    readonly repository: Schema.optionalKey<Schema.String>;
+    readonly target: Schema.optionalKey<Schema.Struct<{
+        readonly branch: Schema.String;
+        readonly head: Schema.String;
+        readonly jobs: Schema.$Array<Schema.Struct<{
+            readonly name: Schema.String;
+            readonly status: Schema.Literals<readonly ["running", "success", "failed", "skipped"]>;
+            readonly url: Schema.optionalKey<Schema.String>;
+            readonly logTail: Schema.optionalKey<Schema.String>;
+        }>>;
+    }>>;
 }>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"ProgramSecrets", Schema.Struct<{
     lease: Schema.Struct<{
         readonly workUnitId: Schema.String;
@@ -1300,6 +1312,8 @@ declare const RunnerCapabilityRpcs_base: RpcGroup.RpcGroup<Rpc.Rpc<"AdmitChild",
         readonly workingDirectory: Schema.optionalKey<Schema.String>;
         readonly suggested: Schema.optionalKey<Schema.Boolean>;
     }>>>;
+    /** Runs a check again whose evidence at the tree failed, rather than reusing that failure; passed evidence is still reused. */
+    rerunFailed: Schema.optionalKey<Schema.Boolean>;
     /** A benchmark against `base` (the Run's base branch head when left out) in place of checks. */
     measure: Schema.optionalKey<Schema.Struct<{
         readonly base: Schema.optionalKey<Schema.String>;
@@ -1833,6 +1847,18 @@ export declare const ProgramRpcs: RpcGroup.RpcGroup<Rpc.Rpc<"AdmitChild", Schema
     }>>;
     readonly readAt: Schema.optionalKey<Schema.String>;
     readonly runnerChecks: Schema.optionalKey<Schema.$Array<Schema.String>>;
+    readonly approved: Schema.optionalKey<Schema.String>;
+    readonly repository: Schema.optionalKey<Schema.String>;
+    readonly target: Schema.optionalKey<Schema.Struct<{
+        readonly branch: Schema.String;
+        readonly head: Schema.String;
+        readonly jobs: Schema.$Array<Schema.Struct<{
+            readonly name: Schema.String;
+            readonly status: Schema.Literals<readonly ["running", "success", "failed", "skipped"]>;
+            readonly url: Schema.optionalKey<Schema.String>;
+            readonly logTail: Schema.optionalKey<Schema.String>;
+        }>>;
+    }>>;
 }>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"ProgramSecrets", Schema.Struct<{
     lease: Schema.Struct<{
         readonly workUnitId: Schema.String;
@@ -2155,6 +2181,8 @@ export declare const ProgramRpcs: RpcGroup.RpcGroup<Rpc.Rpc<"AdmitChild", Schema
         readonly workingDirectory: Schema.optionalKey<Schema.String>;
         readonly suggested: Schema.optionalKey<Schema.Boolean>;
     }>>>;
+    /** Runs a check again whose evidence at the tree failed, rather than reusing that failure; passed evidence is still reused. */
+    rerunFailed: Schema.optionalKey<Schema.Boolean>;
     /** A benchmark against `base` (the Run's base branch head when left out) in place of checks. */
     measure: Schema.optionalKey<Schema.Struct<{
         readonly base: Schema.optionalKey<Schema.String>;
@@ -3039,6 +3067,18 @@ export declare const RunnerRpcs: RpcGroup.RpcGroup<Rpc.Rpc<"AdmitChild", Schema.
     }>>;
     readonly readAt: Schema.optionalKey<Schema.String>;
     readonly runnerChecks: Schema.optionalKey<Schema.$Array<Schema.String>>;
+    readonly approved: Schema.optionalKey<Schema.String>;
+    readonly repository: Schema.optionalKey<Schema.String>;
+    readonly target: Schema.optionalKey<Schema.Struct<{
+        readonly branch: Schema.String;
+        readonly head: Schema.String;
+        readonly jobs: Schema.$Array<Schema.Struct<{
+            readonly name: Schema.String;
+            readonly status: Schema.Literals<readonly ["running", "success", "failed", "skipped"]>;
+            readonly url: Schema.optionalKey<Schema.String>;
+            readonly logTail: Schema.optionalKey<Schema.String>;
+        }>>;
+    }>>;
 }>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"ProgramSecrets", Schema.Struct<{
     lease: Schema.Struct<{
         readonly workUnitId: Schema.String;
@@ -3453,6 +3493,8 @@ export declare const RunnerRpcs: RpcGroup.RpcGroup<Rpc.Rpc<"AdmitChild", Schema.
         readonly workingDirectory: Schema.optionalKey<Schema.String>;
         readonly suggested: Schema.optionalKey<Schema.Boolean>;
     }>>>;
+    /** Runs a check again whose evidence at the tree failed, rather than reusing that failure; passed evidence is still reused. */
+    rerunFailed: Schema.optionalKey<Schema.Boolean>;
     /** A benchmark against `base` (the Run's base branch head when left out) in place of checks. */
     measure: Schema.optionalKey<Schema.Struct<{
         readonly base: Schema.optionalKey<Schema.String>;

package/types/packages/sdk/src/loop/activities.d.ts

@@ -260,6 +260,25 @@ export declare const PipelineStatus: Schema.Struct<{
      * with `verify` on the head and posts the result with `reportPipeline`, and may do so again for a failure it doubts.
      */
     readonly runnerChecks: Schema.optionalKey<Schema.$Array<Schema.String>>;
+    /** The newest head of the ChangeRequest an approval in Kitman covers, with no request for changes on it since. */
+    readonly approved: Schema.optionalKey<Schema.String>;
+    /** The ChangeRequest's RepoBinding. */
+    readonly repository: Schema.optionalKey<Schema.String>;
+    /**
+     * While the pipeline fails: the head of the ChangeRequest's target branch and the forge's checks on it, none where
+     * the forge runs no pipeline. Left out when the forge could not say.
+     */
+    readonly target: Schema.optionalKey<Schema.Struct<{
+        readonly branch: Schema.String;
+        readonly head: Schema.String;
+        readonly jobs: Schema.$Array<Schema.Struct<{
+            readonly name: Schema.String;
+            readonly status: Schema.Literals<readonly ["running", "success", "failed", "skipped"]>;
+            readonly url: Schema.optional<Schema.String>;
+            /** The redacted end of a failed job's log, at most 4000 characters, where the forge serves job logs. */
+            readonly logTail: Schema.optional<Schema.String>;
+        }>>;
+    }>>;
 }>;
 export type PipelineStatus = typeof PipelineStatus.Type;
 /** A review conversation not yet resolved, with its comments oldest first. */
@@ -728,6 +747,18 @@ export declare const pipelineStatus: (name: string, request: typeof ChangeReques
     }[];
     readonly readAt?: string;
     readonly runnerChecks?: readonly string[];
+    readonly approved?: string;
+    readonly repository?: string;
+    readonly target?: {
+        readonly branch: string;
+        readonly head: string;
+        readonly jobs: readonly {
+            readonly name: string;
+            readonly status: "failed" | "running" | "skipped" | "success";
+            readonly url?: string | undefined;
+            readonly logTail?: string | undefined;
+        }[];
+    };
 }, import("./steps").CapabilityDenied | import("./steps").DuplicateStep | StepFailed, ChangeRequestReadActivity | import("./steps").LoopRun | import("effect/workflow/WorkflowEngine").WorkflowEngine | import("effect/workflow/WorkflowEngine").WorkflowInstance>;
 /** A ChangeRequest's unresolved review conversations, read when the Step runs. */
 export declare const reviewThreads: (name: string, request: typeof ChangeRequestReadRequest.Type) => Effect.Effect<{

package/types/packages/sdk/src/loop/steps.d.ts

@@ -145,6 +145,8 @@ export type VerificationLaunch = Launch & {
     readonly checks?: readonly string[];
     /** Run in place of approved checks when the repository has none approved, labelled as suggested. */
     readonly suggested?: readonly SuggestedVerification[];
+    /** Runs a check again whose evidence at the tree failed, rather than reusing that failure; passed evidence is still reused. */
+    readonly rerunFailed?: boolean;
     /** Benchmarks the revision against `base` (the Run's base branch head when left out) in place of checks. */
     readonly measure?: MeasureLaunch;
 };
@@ -320,6 +322,8 @@ export declare const verify: (name: string, request: {
      * up still gets evidence; ignored once any check is approved.
      */
     readonly suggested?: readonly SuggestedVerification[];
+    /** Runs a check again whose evidence at the tree failed, rather than reusing that failure; passed evidence is still reused. */
+    readonly rerunFailed?: boolean;
 }) => Effect.Effect<{
     readonly revision: string;
     readonly tree: string;

package/types/packages/sdk/src/loop/test-loop.d.ts

@@ -7,7 +7,7 @@ import { type LoopCapability, type LoopDefinition } from './define';
 import type { MeasureEvidence } from '../../../core/src/work-unit';
 import type { VerifyResult } from './evidence';
 import { type ClaimResult } from './claims';
-import { InputInvalid, LoopHost, LoopRun, type EventWaitLaunch, type LoopEvent, type StepRecord } from './steps';
+import { InputInvalid, LoopHost, LoopRun, type EventWaitLaunch, type LoopEvent, type StepRecord, type VerificationLaunch } from './steps';
 /** Activity and deferred results, encoded as JSON; replaying from it runs no Activity again. */
 export declare const LoopJournal: Schema.Struct<{
     readonly activities: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
@@ -73,6 +73,15 @@ export type TestLoopScript = {
     readonly claims?: {
         readonly [step: string]: ClaimResult;
     };
+    /**
+     * Settles each claim and let go itself, as a queue that several test Runs share does: what it gives a claim wins over
+     * `claims`, and a claim waits for as long as it takes.
+     */
+    readonly claimed?: (request: {
+        readonly step: string;
+        readonly resource: string;
+        readonly action: 'claim' | 'take_over' | 'let_go';
+    }) => Effect.Effect<ClaimResult | undefined>;
     /** What the control plane grants; the declared capabilities by default. */
     readonly grant?: readonly LoopCapability[];
     /** Replaces the default host Activities method by method; a method left out keeps its default. */
@@ -101,8 +110,11 @@ export type TestLoopResult<Out, E> = {
     readonly childLaunches: readonly ChildLaunchRecord[];
     /** Every `waitFor` started, in order. */
     readonly waits: readonly WaitRecord[];
+    /** Every `verify` started, in order. */
+    readonly verifyLaunches: readonly VerifyRecord[];
 };
 type WaitRecord = Pick<EventWaitLaunch, 'step' | 'event' | 'filter' | 'since' | 'or'>;
+type VerifyRecord = Pick<VerificationLaunch, 'step' | 'revision' | 'checks' | 'rerunFailed'>;
 type AgentLaunchRecord = {
     readonly step: string;
     readonly agent: string;

package/types/packages/sdk/src/program/engine.d.ts

@@ -54,6 +54,7 @@ export type ProgramCapabilities = {
         readonly revision?: string;
         readonly checks?: readonly string[];
         readonly suggested?: readonly SuggestedVerification[];
+        readonly rerunFailed?: boolean;
         readonly measure?: MeasureLaunch;
     }) => Effect.Effect<{
         readonly verificationId: string;