@kitman-sh/sdk 0.10.67 → 0.10.69

package/dist/build/index.js

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

package/dist/{chunk-x37rn3aw.js → chunk-8z4xvm69.js}

@@ -33,7 +33,7 @@ import {
   executeLoop2,
   LoopCheckError2,
   checkLoop2
-} from "./chunk-dnmb9dw9.js";
+} from "./chunk-abjq7rp4.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,
@@ -1402,6 +1403,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 +1627,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-abjq7rp4.js}

@@ -3034,6 +3034,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);
@@ -4129,7 +4130,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({
@@ -4159,6 +4160,13 @@ var scriptedHost = (script, engine, agentLaunches, childLaunches, waits) => {
     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 })),
     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 +4217,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 +4230,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 +4240,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-abjq7rp4.js";
 export {
   AlertTaskActivity2 as AlertTaskActivity,
   AlertTaskRequest2 as AlertTaskRequest,

package/dist/program/index.js

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

package/package.json

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

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: {

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

@@ -123,65 +123,7 @@ export declare const ProgramOutcome: Schema.Union<readonly [Schema.Struct<{
     readonly status: Schema.Literal<"failed">;
     readonly failureSummary: Schema.String;
 }>]>;
-declare const RunnerReplicaRpcs_base: RpcGroup.RpcGroup<Rpc.Rpc<"Signals", Schema.Struct<{
-    runnerReplicaId: Schema.String;
-}>, import("effect/rpc/RpcSchema").Stream<Schema.Union<readonly [Schema.TaggedStruct<"WorkAvailable", {}>, Schema.TaggedStruct<"LeaseRevoked", {
-    readonly workUnitId: Schema.String;
-}>, Schema.TaggedStruct<"Settled", {
-    readonly workUnitId: Schema.String;
-}>, Schema.TaggedStruct<"Canceled", {
-    readonly workUnitId: Schema.String;
-}>, Schema.TaggedStruct<"RunSettled", {
-    readonly runId: Schema.String;
-}>, Schema.TaggedStruct<"Steer", {
-    readonly workUnitId: Schema.String;
-    readonly messageId: Schema.String;
-    readonly text: Schema.String;
-}>, Schema.TaggedStruct<"SessionUpdated", {
-    readonly workUnitId: Schema.String;
-}>, Schema.TaggedStruct<"UpdateAvailable", {
-    readonly version: Schema.String;
-}>]>, typeof RunnerRpcError>, Schema.Never, typeof RunnerAuthentication, never> | Rpc.Rpc<"CreateCheckpointFile", Schema.Struct<{
-    lease: Schema.Struct<{
-        readonly workUnitId: Schema.String;
-        readonly leaseOwnerId: Schema.String;
-        readonly runnerReplicaId: Schema.String;
-        readonly leaseId: Schema.String;
-        readonly attempt: Schema.Int;
-        readonly fencingToken: Schema.String;
-        readonly capacitySlot: Schema.String;
-    }>;
-    byteSize: Schema.Int;
-    sha256: Schema.String;
-}>, Schema.Struct<{
-    readonly file: Schema.Struct<{
-        readonly id: Schema.String;
-        readonly runId: Schema.String;
-        readonly step: Schema.String;
-        readonly name: Schema.String;
-        readonly caption: Schema.optionalKey<Schema.String>;
-        readonly contentType: Schema.String;
-        readonly kind: Schema.Literals<readonly ["image", "video", "html", "text", "other"]>;
-        readonly byteSize: Schema.Int;
-        readonly sha256: Schema.String;
-        readonly status: Schema.Literals<readonly ["uploading", "available", "rejected", "refused", "removing", "removed", "expired"]>;
-    }>;
-    readonly upload: Schema.optional<Schema.Union<readonly [Schema.Struct<{
-        readonly url: Schema.String;
-        readonly headers: Schema.optionalKey<Schema.$Record<Schema.String, Schema.String>>;
-        readonly expiresAt: Schema.String;
-        readonly kind: Schema.Literal<"single">;
-    }>, Schema.Struct<{
-        readonly kind: Schema.Literal<"multipart">;
-        readonly partSize: Schema.Int;
-        readonly parts: Schema.$Array<Schema.Struct<{
-            readonly url: Schema.String;
-            readonly headers: Schema.optionalKey<Schema.$Record<Schema.String, Schema.String>>;
-            readonly expiresAt: Schema.String;
-            readonly partNumber: Schema.Int;
-        }>>;
-    }>]>>;
-}>, Schema.Union<readonly [typeof RunnerRpcError, typeof RunFileRefused]>, typeof RunnerAuthentication, never> | Rpc.Rpc<"AppendTranscript", Schema.Struct<{
+declare const RunnerReplicaRpcs_base: RpcGroup.RpcGroup<Rpc.Rpc<"AppendTranscript", Schema.Struct<{
     workUnitId: Schema.String;
     entries: Schema.$Array<Schema.Struct<{
         readonly sequence: Schema.Int;
@@ -535,7 +477,47 @@ declare const RunnerReplicaRpcs_base: RpcGroup.RpcGroup<Rpc.Rpc<"Signals", Schem
     readonly byteSize: Schema.Int;
     readonly sha256: Schema.String;
     readonly status: Schema.Literals<readonly ["uploading", "available", "rejected", "refused", "removing", "removed", "expired"]>;
-}>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"ForgetCheckpoints", Schema.Struct<{
+}>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"CreateCheckpointFile", Schema.Struct<{
+    lease: Schema.Struct<{
+        readonly workUnitId: Schema.String;
+        readonly leaseOwnerId: Schema.String;
+        readonly runnerReplicaId: Schema.String;
+        readonly leaseId: Schema.String;
+        readonly attempt: Schema.Int;
+        readonly fencingToken: Schema.String;
+        readonly capacitySlot: Schema.String;
+    }>;
+    byteSize: Schema.Int;
+    sha256: Schema.String;
+}>, Schema.Struct<{
+    readonly file: Schema.Struct<{
+        readonly id: Schema.String;
+        readonly runId: Schema.String;
+        readonly step: Schema.String;
+        readonly name: Schema.String;
+        readonly caption: Schema.optionalKey<Schema.String>;
+        readonly contentType: Schema.String;
+        readonly kind: Schema.Literals<readonly ["image", "video", "html", "text", "other"]>;
+        readonly byteSize: Schema.Int;
+        readonly sha256: Schema.String;
+        readonly status: Schema.Literals<readonly ["uploading", "available", "rejected", "refused", "removing", "removed", "expired"]>;
+    }>;
+    readonly upload: Schema.optional<Schema.Union<readonly [Schema.Struct<{
+        readonly url: Schema.String;
+        readonly headers: Schema.optionalKey<Schema.$Record<Schema.String, Schema.String>>;
+        readonly expiresAt: Schema.String;
+        readonly kind: Schema.Literal<"single">;
+    }>, Schema.Struct<{
+        readonly kind: Schema.Literal<"multipart">;
+        readonly partSize: Schema.Int;
+        readonly parts: Schema.$Array<Schema.Struct<{
+            readonly url: Schema.String;
+            readonly headers: Schema.optionalKey<Schema.$Record<Schema.String, Schema.String>>;
+            readonly expiresAt: Schema.String;
+            readonly partNumber: Schema.Int;
+        }>>;
+    }>]>>;
+}>, Schema.Union<readonly [typeof RunnerRpcError, typeof RunFileRefused]>, typeof RunnerAuthentication, never> | Rpc.Rpc<"ForgetCheckpoints", Schema.Struct<{
     stepAttemptIds: Schema.$Array<Schema.String>;
 }>, Schema.Void, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"GitCredential", Schema.Struct<{
     repoBindingId: Schema.String;
@@ -652,7 +634,25 @@ declare const RunnerReplicaRpcs_base: RpcGroup.RpcGroup<Rpc.Rpc<"Signals", Schem
     }>>;
 }>>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"SettledRuns", Schema.Struct<{
     runIds: Schema.$Array<Schema.String>;
-}>, Schema.$Array<Schema.String>, typeof RunnerRpcError, typeof RunnerAuthentication, never>>;
+}>, Schema.$Array<Schema.String>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"Signals", Schema.Struct<{
+    runnerReplicaId: Schema.String;
+}>, import("effect/rpc/RpcSchema").Stream<Schema.Union<readonly [Schema.TaggedStruct<"WorkAvailable", {}>, Schema.TaggedStruct<"LeaseRevoked", {
+    readonly workUnitId: Schema.String;
+}>, Schema.TaggedStruct<"Settled", {
+    readonly workUnitId: Schema.String;
+}>, Schema.TaggedStruct<"Canceled", {
+    readonly workUnitId: Schema.String;
+}>, Schema.TaggedStruct<"RunSettled", {
+    readonly runId: Schema.String;
+}>, Schema.TaggedStruct<"Steer", {
+    readonly workUnitId: Schema.String;
+    readonly messageId: Schema.String;
+    readonly text: Schema.String;
+}>, Schema.TaggedStruct<"SessionUpdated", {
+    readonly workUnitId: Schema.String;
+}>, Schema.TaggedStruct<"UpdateAvailable", {
+    readonly version: Schema.String;
+}>]>, typeof RunnerRpcError>, Schema.Never, typeof RunnerAuthentication, never>>;
 /** The Runner process's procedures: Work Unit leases, signals, checkpoints and bundles. */
 export declare class RunnerReplicaRpcs extends RunnerReplicaRpcs_base {
 }
@@ -1300,6 +1300,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>;
@@ -1342,51 +1344,7 @@ declare const RunnerCapabilityRpcs_base: RpcGroup.RpcGroup<Rpc.Rpc<"AdmitChild",
 /** A program's domain calls. */
 export declare class RunnerCapabilityRpcs extends RunnerCapabilityRpcs_base {
 }
-declare const RunnerRunFileRpcs_base: RpcGroup.RpcGroup<Rpc.Rpc<"CreateRunFile", Schema.Struct<{
-    lease: Schema.Struct<{
-        readonly workUnitId: Schema.String;
-        readonly leaseOwnerId: Schema.String;
-        readonly runnerReplicaId: Schema.String;
-        readonly leaseId: Schema.String;
-        readonly attempt: Schema.Int;
-        readonly fencingToken: Schema.String;
-        readonly capacitySlot: Schema.String;
-    }>;
-    step: Schema.String;
-    name: Schema.String;
-    caption: Schema.optional<Schema.String>;
-    contentType: Schema.String;
-    byteSize: Schema.Int;
-    sha256: Schema.String;
-}>, Schema.Struct<{
-    readonly file: Schema.Struct<{
-        readonly id: Schema.String;
-        readonly runId: Schema.String;
-        readonly step: Schema.String;
-        readonly name: Schema.String;
-        readonly caption: Schema.optionalKey<Schema.String>;
-        readonly contentType: Schema.String;
-        readonly kind: Schema.Literals<readonly ["image", "video", "html", "text", "other"]>;
-        readonly byteSize: Schema.Int;
-        readonly sha256: Schema.String;
-        readonly status: Schema.Literals<readonly ["uploading", "available", "rejected", "refused", "removing", "removed", "expired"]>;
-    }>;
-    readonly upload: Schema.optional<Schema.Union<readonly [Schema.Struct<{
-        readonly url: Schema.String;
-        readonly headers: Schema.optionalKey<Schema.$Record<Schema.String, Schema.String>>;
-        readonly expiresAt: Schema.String;
-        readonly kind: Schema.Literal<"single">;
-    }>, Schema.Struct<{
-        readonly kind: Schema.Literal<"multipart">;
-        readonly partSize: Schema.Int;
-        readonly parts: Schema.$Array<Schema.Struct<{
-            readonly url: Schema.String;
-            readonly headers: Schema.optionalKey<Schema.$Record<Schema.String, Schema.String>>;
-            readonly expiresAt: Schema.String;
-            readonly partNumber: Schema.Int;
-        }>>;
-    }>]>>;
-}>, Schema.Union<readonly [typeof RunnerRpcError, typeof RunFileRefused]>, typeof RunnerAuthentication, never> | Rpc.Rpc<"CompleteRunFile", Schema.Struct<{
+declare const RunnerRunFileRpcs_base: RpcGroup.RpcGroup<Rpc.Rpc<"CompleteRunFile", Schema.Struct<{
     lease: Schema.Struct<{
         readonly workUnitId: Schema.String;
         readonly leaseOwnerId: Schema.String;
@@ -1412,31 +1370,7 @@ declare const RunnerRunFileRpcs_base: RpcGroup.RpcGroup<Rpc.Rpc<"CreateRunFile",
     readonly byteSize: Schema.Int;
     readonly sha256: Schema.String;
     readonly status: Schema.Literals<readonly ["uploading", "available", "rejected", "refused", "removing", "removed", "expired"]>;
-}>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"RunFileParts", Schema.Struct<{
-    lease: Schema.Struct<{
-        readonly workUnitId: Schema.String;
-        readonly leaseOwnerId: Schema.String;
-        readonly runnerReplicaId: Schema.String;
-        readonly leaseId: Schema.String;
-        readonly attempt: Schema.Int;
-        readonly fencingToken: Schema.String;
-        readonly capacitySlot: Schema.String;
-    }>;
-    fileId: Schema.String;
-    partNumbers: Schema.$Array<Schema.Int>;
-}>, Schema.Struct<{
-    readonly parts: Schema.$Array<Schema.Struct<{
-        readonly url: Schema.String;
-        readonly headers: Schema.optionalKey<Schema.$Record<Schema.String, Schema.String>>;
-        readonly expiresAt: Schema.String;
-        readonly partNumber: Schema.Int;
-    }>>;
-}>, typeof RunnerRpcError, typeof RunnerAuthentication, never>>;
-/** Run File uploads, under a program's orchestration lease or the Runner's verification lease. */
-export declare class RunnerRunFileRpcs extends RunnerRunFileRpcs_base {
-}
-/** What a program process may call; its bundle speaks the Runner RPC protocol version through these. */
-export declare const ProgramRpcs: RpcGroup.RpcGroup<Rpc.Rpc<"CreateRunFile", Schema.Struct<{
+}>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"CreateRunFile", Schema.Struct<{
     lease: Schema.Struct<{
         readonly workUnitId: Schema.String;
         readonly leaseOwnerId: Schema.String;
@@ -1480,7 +1414,31 @@ export declare const ProgramRpcs: RpcGroup.RpcGroup<Rpc.Rpc<"CreateRunFile", Sch
             readonly partNumber: Schema.Int;
         }>>;
     }>]>>;
-}>, Schema.Union<readonly [typeof RunnerRpcError, typeof RunFileRefused]>, typeof RunnerAuthentication, never> | Rpc.Rpc<"AdmitChild", Schema.Struct<{
+}>, Schema.Union<readonly [typeof RunnerRpcError, typeof RunFileRefused]>, typeof RunnerAuthentication, never> | Rpc.Rpc<"RunFileParts", Schema.Struct<{
+    lease: Schema.Struct<{
+        readonly workUnitId: Schema.String;
+        readonly leaseOwnerId: Schema.String;
+        readonly runnerReplicaId: Schema.String;
+        readonly leaseId: Schema.String;
+        readonly attempt: Schema.Int;
+        readonly fencingToken: Schema.String;
+        readonly capacitySlot: Schema.String;
+    }>;
+    fileId: Schema.String;
+    partNumbers: Schema.$Array<Schema.Int>;
+}>, Schema.Struct<{
+    readonly parts: Schema.$Array<Schema.Struct<{
+        readonly url: Schema.String;
+        readonly headers: Schema.optionalKey<Schema.$Record<Schema.String, Schema.String>>;
+        readonly expiresAt: Schema.String;
+        readonly partNumber: Schema.Int;
+    }>>;
+}>, typeof RunnerRpcError, typeof RunnerAuthentication, never>>;
+/** Run File uploads, under a program's orchestration lease or the Runner's verification lease. */
+export declare class RunnerRunFileRpcs extends RunnerRunFileRpcs_base {
+}
+/** What a program process may call; its bundle speaks the Runner RPC protocol version through these. */
+export declare const ProgramRpcs: RpcGroup.RpcGroup<Rpc.Rpc<"AdmitChild", Schema.Struct<{
     lease: Schema.Struct<{
         readonly workUnitId: Schema.String;
         readonly leaseOwnerId: Schema.String;
@@ -1645,7 +1603,51 @@ export declare const ProgramRpcs: RpcGroup.RpcGroup<Rpc.Rpc<"CreateRunFile", Sch
 }>, Schema.$Array<Schema.Struct<{
     readonly key: Schema.String;
     readonly taskId: Schema.String;
-}>>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"DeferredDone", Schema.Struct<{
+}>>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"CreateRunFile", Schema.Struct<{
+    lease: Schema.Struct<{
+        readonly workUnitId: Schema.String;
+        readonly leaseOwnerId: Schema.String;
+        readonly runnerReplicaId: Schema.String;
+        readonly leaseId: Schema.String;
+        readonly attempt: Schema.Int;
+        readonly fencingToken: Schema.String;
+        readonly capacitySlot: Schema.String;
+    }>;
+    step: Schema.String;
+    name: Schema.String;
+    caption: Schema.optional<Schema.String>;
+    contentType: Schema.String;
+    byteSize: Schema.Int;
+    sha256: Schema.String;
+}>, Schema.Struct<{
+    readonly file: Schema.Struct<{
+        readonly id: Schema.String;
+        readonly runId: Schema.String;
+        readonly step: Schema.String;
+        readonly name: Schema.String;
+        readonly caption: Schema.optionalKey<Schema.String>;
+        readonly contentType: Schema.String;
+        readonly kind: Schema.Literals<readonly ["image", "video", "html", "text", "other"]>;
+        readonly byteSize: Schema.Int;
+        readonly sha256: Schema.String;
+        readonly status: Schema.Literals<readonly ["uploading", "available", "rejected", "refused", "removing", "removed", "expired"]>;
+    }>;
+    readonly upload: Schema.optional<Schema.Union<readonly [Schema.Struct<{
+        readonly url: Schema.String;
+        readonly headers: Schema.optionalKey<Schema.$Record<Schema.String, Schema.String>>;
+        readonly expiresAt: Schema.String;
+        readonly kind: Schema.Literal<"single">;
+    }>, Schema.Struct<{
+        readonly kind: Schema.Literal<"multipart">;
+        readonly partSize: Schema.Int;
+        readonly parts: Schema.$Array<Schema.Struct<{
+            readonly url: Schema.String;
+            readonly headers: Schema.optionalKey<Schema.$Record<Schema.String, Schema.String>>;
+            readonly expiresAt: Schema.String;
+            readonly partNumber: Schema.Int;
+        }>>;
+    }>]>>;
+}>, Schema.Union<readonly [typeof RunnerRpcError, typeof RunFileRefused]>, typeof RunnerAuthentication, never> | Rpc.Rpc<"DeferredDone", Schema.Struct<{
     lease: Schema.Struct<{
         readonly workUnitId: Schema.String;
         readonly leaseOwnerId: Schema.String;
@@ -2155,6 +2157,8 @@ export declare const ProgramRpcs: RpcGroup.RpcGroup<Rpc.Rpc<"CreateRunFile", Sch
         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>;
@@ -2205,109 +2209,7 @@ export declare const ProgramRpcs: RpcGroup.RpcGroup<Rpc.Rpc<"CreateRunFile", Sch
     }>;
 }>, Schema.Void, typeof RunnerRpcError, typeof RunnerAuthentication, never>>;
 /** Every group, served on the one Runner RPC endpoint; a request names its procedure by tag alone. */
-export declare const RunnerRpcs: RpcGroup.RpcGroup<Rpc.Rpc<"Signals", Schema.Struct<{
-    runnerReplicaId: Schema.String;
-}>, import("effect/rpc/RpcSchema").Stream<Schema.Union<readonly [Schema.TaggedStruct<"WorkAvailable", {}>, Schema.TaggedStruct<"LeaseRevoked", {
-    readonly workUnitId: Schema.String;
-}>, Schema.TaggedStruct<"Settled", {
-    readonly workUnitId: Schema.String;
-}>, Schema.TaggedStruct<"Canceled", {
-    readonly workUnitId: Schema.String;
-}>, Schema.TaggedStruct<"RunSettled", {
-    readonly runId: Schema.String;
-}>, Schema.TaggedStruct<"Steer", {
-    readonly workUnitId: Schema.String;
-    readonly messageId: Schema.String;
-    readonly text: Schema.String;
-}>, Schema.TaggedStruct<"SessionUpdated", {
-    readonly workUnitId: Schema.String;
-}>, Schema.TaggedStruct<"UpdateAvailable", {
-    readonly version: Schema.String;
-}>]>, typeof RunnerRpcError>, Schema.Never, typeof RunnerAuthentication, never> | Rpc.Rpc<"CreateCheckpointFile", Schema.Struct<{
-    lease: Schema.Struct<{
-        readonly workUnitId: Schema.String;
-        readonly leaseOwnerId: Schema.String;
-        readonly runnerReplicaId: Schema.String;
-        readonly leaseId: Schema.String;
-        readonly attempt: Schema.Int;
-        readonly fencingToken: Schema.String;
-        readonly capacitySlot: Schema.String;
-    }>;
-    byteSize: Schema.Int;
-    sha256: Schema.String;
-}>, Schema.Struct<{
-    readonly file: Schema.Struct<{
-        readonly id: Schema.String;
-        readonly runId: Schema.String;
-        readonly step: Schema.String;
-        readonly name: Schema.String;
-        readonly caption: Schema.optionalKey<Schema.String>;
-        readonly contentType: Schema.String;
-        readonly kind: Schema.Literals<readonly ["image", "video", "html", "text", "other"]>;
-        readonly byteSize: Schema.Int;
-        readonly sha256: Schema.String;
-        readonly status: Schema.Literals<readonly ["uploading", "available", "rejected", "refused", "removing", "removed", "expired"]>;
-    }>;
-    readonly upload: Schema.optional<Schema.Union<readonly [Schema.Struct<{
-        readonly url: Schema.String;
-        readonly headers: Schema.optionalKey<Schema.$Record<Schema.String, Schema.String>>;
-        readonly expiresAt: Schema.String;
-        readonly kind: Schema.Literal<"single">;
-    }>, Schema.Struct<{
-        readonly kind: Schema.Literal<"multipart">;
-        readonly partSize: Schema.Int;
-        readonly parts: Schema.$Array<Schema.Struct<{
-            readonly url: Schema.String;
-            readonly headers: Schema.optionalKey<Schema.$Record<Schema.String, Schema.String>>;
-            readonly expiresAt: Schema.String;
-            readonly partNumber: Schema.Int;
-        }>>;
-    }>]>>;
-}>, Schema.Union<readonly [typeof RunnerRpcError, typeof RunFileRefused]>, typeof RunnerAuthentication, never> | Rpc.Rpc<"CreateRunFile", Schema.Struct<{
-    lease: Schema.Struct<{
-        readonly workUnitId: Schema.String;
-        readonly leaseOwnerId: Schema.String;
-        readonly runnerReplicaId: Schema.String;
-        readonly leaseId: Schema.String;
-        readonly attempt: Schema.Int;
-        readonly fencingToken: Schema.String;
-        readonly capacitySlot: Schema.String;
-    }>;
-    step: Schema.String;
-    name: Schema.String;
-    caption: Schema.optional<Schema.String>;
-    contentType: Schema.String;
-    byteSize: Schema.Int;
-    sha256: Schema.String;
-}>, Schema.Struct<{
-    readonly file: Schema.Struct<{
-        readonly id: Schema.String;
-        readonly runId: Schema.String;
-        readonly step: Schema.String;
-        readonly name: Schema.String;
-        readonly caption: Schema.optionalKey<Schema.String>;
-        readonly contentType: Schema.String;
-        readonly kind: Schema.Literals<readonly ["image", "video", "html", "text", "other"]>;
-        readonly byteSize: Schema.Int;
-        readonly sha256: Schema.String;
-        readonly status: Schema.Literals<readonly ["uploading", "available", "rejected", "refused", "removing", "removed", "expired"]>;
-    }>;
-    readonly upload: Schema.optional<Schema.Union<readonly [Schema.Struct<{
-        readonly url: Schema.String;
-        readonly headers: Schema.optionalKey<Schema.$Record<Schema.String, Schema.String>>;
-        readonly expiresAt: Schema.String;
-        readonly kind: Schema.Literal<"single">;
-    }>, Schema.Struct<{
-        readonly kind: Schema.Literal<"multipart">;
-        readonly partSize: Schema.Int;
-        readonly parts: Schema.$Array<Schema.Struct<{
-            readonly url: Schema.String;
-            readonly headers: Schema.optionalKey<Schema.$Record<Schema.String, Schema.String>>;
-            readonly expiresAt: Schema.String;
-            readonly partNumber: Schema.Int;
-        }>>;
-    }>]>>;
-}>, Schema.Union<readonly [typeof RunnerRpcError, typeof RunFileRefused]>, typeof RunnerAuthentication, never> | Rpc.Rpc<"AdmitChild", Schema.Struct<{
+export declare const RunnerRpcs: RpcGroup.RpcGroup<Rpc.Rpc<"AdmitChild", Schema.Struct<{
     lease: Schema.Struct<{
         readonly workUnitId: Schema.String;
         readonly leaseOwnerId: Schema.String;
@@ -2804,7 +2706,47 @@ export declare const RunnerRpcs: RpcGroup.RpcGroup<Rpc.Rpc<"Signals", Schema.Str
     readonly byteSize: Schema.Int;
     readonly sha256: Schema.String;
     readonly status: Schema.Literals<readonly ["uploading", "available", "rejected", "refused", "removing", "removed", "expired"]>;
-}>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"CreatePlanTasks", Schema.Struct<{
+}>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"CreateCheckpointFile", Schema.Struct<{
+    lease: Schema.Struct<{
+        readonly workUnitId: Schema.String;
+        readonly leaseOwnerId: Schema.String;
+        readonly runnerReplicaId: Schema.String;
+        readonly leaseId: Schema.String;
+        readonly attempt: Schema.Int;
+        readonly fencingToken: Schema.String;
+        readonly capacitySlot: Schema.String;
+    }>;
+    byteSize: Schema.Int;
+    sha256: Schema.String;
+}>, Schema.Struct<{
+    readonly file: Schema.Struct<{
+        readonly id: Schema.String;
+        readonly runId: Schema.String;
+        readonly step: Schema.String;
+        readonly name: Schema.String;
+        readonly caption: Schema.optionalKey<Schema.String>;
+        readonly contentType: Schema.String;
+        readonly kind: Schema.Literals<readonly ["image", "video", "html", "text", "other"]>;
+        readonly byteSize: Schema.Int;
+        readonly sha256: Schema.String;
+        readonly status: Schema.Literals<readonly ["uploading", "available", "rejected", "refused", "removing", "removed", "expired"]>;
+    }>;
+    readonly upload: Schema.optional<Schema.Union<readonly [Schema.Struct<{
+        readonly url: Schema.String;
+        readonly headers: Schema.optionalKey<Schema.$Record<Schema.String, Schema.String>>;
+        readonly expiresAt: Schema.String;
+        readonly kind: Schema.Literal<"single">;
+    }>, Schema.Struct<{
+        readonly kind: Schema.Literal<"multipart">;
+        readonly partSize: Schema.Int;
+        readonly parts: Schema.$Array<Schema.Struct<{
+            readonly url: Schema.String;
+            readonly headers: Schema.optionalKey<Schema.$Record<Schema.String, Schema.String>>;
+            readonly expiresAt: Schema.String;
+            readonly partNumber: Schema.Int;
+        }>>;
+    }>]>>;
+}>, Schema.Union<readonly [typeof RunnerRpcError, typeof RunFileRefused]>, typeof RunnerAuthentication, never> | Rpc.Rpc<"CreatePlanTasks", Schema.Struct<{
     lease: Schema.Struct<{
         readonly workUnitId: Schema.String;
         readonly leaseOwnerId: Schema.String;
@@ -2826,7 +2768,51 @@ export declare const RunnerRpcs: RpcGroup.RpcGroup<Rpc.Rpc<"Signals", Schema.Str
 }>, Schema.$Array<Schema.Struct<{
     readonly key: Schema.String;
     readonly taskId: Schema.String;
-}>>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"DeferredDone", Schema.Struct<{
+}>>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"CreateRunFile", Schema.Struct<{
+    lease: Schema.Struct<{
+        readonly workUnitId: Schema.String;
+        readonly leaseOwnerId: Schema.String;
+        readonly runnerReplicaId: Schema.String;
+        readonly leaseId: Schema.String;
+        readonly attempt: Schema.Int;
+        readonly fencingToken: Schema.String;
+        readonly capacitySlot: Schema.String;
+    }>;
+    step: Schema.String;
+    name: Schema.String;
+    caption: Schema.optional<Schema.String>;
+    contentType: Schema.String;
+    byteSize: Schema.Int;
+    sha256: Schema.String;
+}>, Schema.Struct<{
+    readonly file: Schema.Struct<{
+        readonly id: Schema.String;
+        readonly runId: Schema.String;
+        readonly step: Schema.String;
+        readonly name: Schema.String;
+        readonly caption: Schema.optionalKey<Schema.String>;
+        readonly contentType: Schema.String;
+        readonly kind: Schema.Literals<readonly ["image", "video", "html", "text", "other"]>;
+        readonly byteSize: Schema.Int;
+        readonly sha256: Schema.String;
+        readonly status: Schema.Literals<readonly ["uploading", "available", "rejected", "refused", "removing", "removed", "expired"]>;
+    }>;
+    readonly upload: Schema.optional<Schema.Union<readonly [Schema.Struct<{
+        readonly url: Schema.String;
+        readonly headers: Schema.optionalKey<Schema.$Record<Schema.String, Schema.String>>;
+        readonly expiresAt: Schema.String;
+        readonly kind: Schema.Literal<"single">;
+    }>, Schema.Struct<{
+        readonly kind: Schema.Literal<"multipart">;
+        readonly partSize: Schema.Int;
+        readonly parts: Schema.$Array<Schema.Struct<{
+            readonly url: Schema.String;
+            readonly headers: Schema.optionalKey<Schema.$Record<Schema.String, Schema.String>>;
+            readonly expiresAt: Schema.String;
+            readonly partNumber: Schema.Int;
+        }>>;
+    }>]>>;
+}>, Schema.Union<readonly [typeof RunnerRpcError, typeof RunFileRefused]>, typeof RunnerAuthentication, never> | Rpc.Rpc<"DeferredDone", Schema.Struct<{
     lease: Schema.Struct<{
         readonly workUnitId: Schema.String;
         readonly leaseOwnerId: Schema.String;
@@ -3407,7 +3393,25 @@ export declare const RunnerRpcs: RpcGroup.RpcGroup<Rpc.Rpc<"Signals", Schema.Str
     }>>;
 }>>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"SettledRuns", Schema.Struct<{
     runIds: Schema.$Array<Schema.String>;
-}>, Schema.$Array<Schema.String>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"StartAgentStep", Schema.Struct<{
+}>, Schema.$Array<Schema.String>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"Signals", Schema.Struct<{
+    runnerReplicaId: Schema.String;
+}>, import("effect/rpc/RpcSchema").Stream<Schema.Union<readonly [Schema.TaggedStruct<"WorkAvailable", {}>, Schema.TaggedStruct<"LeaseRevoked", {
+    readonly workUnitId: Schema.String;
+}>, Schema.TaggedStruct<"Settled", {
+    readonly workUnitId: Schema.String;
+}>, Schema.TaggedStruct<"Canceled", {
+    readonly workUnitId: Schema.String;
+}>, Schema.TaggedStruct<"RunSettled", {
+    readonly runId: Schema.String;
+}>, Schema.TaggedStruct<"Steer", {
+    readonly workUnitId: Schema.String;
+    readonly messageId: Schema.String;
+    readonly text: Schema.String;
+}>, Schema.TaggedStruct<"SessionUpdated", {
+    readonly workUnitId: Schema.String;
+}>, Schema.TaggedStruct<"UpdateAvailable", {
+    readonly version: Schema.String;
+}>]>, typeof RunnerRpcError>, Schema.Never, typeof RunnerAuthentication, never> | Rpc.Rpc<"StartAgentStep", Schema.Struct<{
     lease: Schema.Struct<{
         readonly workUnitId: Schema.String;
         readonly leaseOwnerId: Schema.String;
@@ -3453,6 +3457,8 @@ export declare const RunnerRpcs: RpcGroup.RpcGroup<Rpc.Rpc<"Signals", Schema.Str
         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/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>>;
@@ -101,8 +101,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;