diff --git a/pkg/apis/pipeline/v1alpha1/pipelinerun_types.go b/pkg/apis/pipeline/v1alpha1/pipelinerun_types.go
index 541ff6244d7..7b88c016371 100644
--- a/pkg/apis/pipeline/v1alpha1/pipelinerun_types.go
+++ b/pkg/apis/pipeline/v1alpha1/pipelinerun_types.go
@@ -21,7 +21,8 @@ import (
 	"fmt"
 	"time"
 
-	duckv1alpha1 "github.com/knative/pkg/apis/duck/v1alpha1"
+	"github.com/knative/pkg/apis"
+	duckv1beta1 "github.com/knative/pkg/apis/duck/v1beta1"
 	corev1 "k8s.io/api/core/v1"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/apimachinery/pkg/runtime/schema"
@@ -113,16 +114,20 @@ type PipelineTrigger struct {
 
 // PipelineRunStatus defines the observed state of PipelineRun
 type PipelineRunStatus struct {
-	Conditions duckv1alpha1.Conditions `json:"conditions"`
+	duckv1beta1.Status `json:",inline"`
+
 	// In #107 should be updated to hold the location logs have been uploaded to
 	// +optional
 	Results *Results `json:"results,omitempty"`
+
 	// StartTime is the time the PipelineRun is actually started.
 	// +optional
 	StartTime *metav1.Time `json:"startTime,omitempty"`
+
 	// CompletionTime is the time the PipelineRun completed.
 	// +optional
 	CompletionTime *metav1.Time `json:"completionTime,omitempty"`
+
 	// map of PipelineRunTaskRunStatus with the taskRun name as the key
 	// +optional
 	TaskRuns map[string]*PipelineRunTaskRunStatus `json:"taskRuns,omitempty"`
@@ -137,10 +142,10 @@ type PipelineRunTaskRunStatus struct {
 	Status *TaskRunStatus `json:"status,omitempty"`
 }
 
-var pipelineRunCondSet = duckv1alpha1.NewBatchConditionSet()
+var pipelineRunCondSet = apis.NewBatchConditionSet()
 
 // GetCondition returns the Condition matching the given type.
-func (pr *PipelineRunStatus) GetCondition(t duckv1alpha1.ConditionType) *duckv1alpha1.Condition {
+func (pr *PipelineRunStatus) GetCondition(t apis.ConditionType) *apis.Condition {
 	return pipelineRunCondSet.Manage(pr).GetCondition(t)
 }
 
@@ -157,7 +162,7 @@ func (pr *PipelineRunStatus) InitializeConditions() {
 
 // SetCondition sets the condition, unsetting previous conditions with the same
 // type as necessary.
-func (pr *PipelineRunStatus) SetCondition(newCond *duckv1alpha1.Condition) {
+func (pr *PipelineRunStatus) SetCondition(newCond *apis.Condition) {
 	if newCond != nil {
 		pipelineRunCondSet.Manage(pr).SetCondition(*newCond)
 	}
@@ -218,7 +223,7 @@ func (pr *PipelineRun) GetOwnerReference() []metav1.OwnerReference {
 
 // IsDone returns true if the PipelineRun's status indicates that it is done.
 func (pr *PipelineRun) IsDone() bool {
-	return !pr.Status.GetCondition(duckv1alpha1.ConditionSucceeded).IsUnknown()
+	return !pr.Status.GetCondition(apis.ConditionSucceeded).IsUnknown()
 }
 
 // HasStarted function check whether pipelinerun has valid start time set in its status
diff --git a/pkg/apis/pipeline/v1alpha1/pipelinerun_types_test.go b/pkg/apis/pipeline/v1alpha1/pipelinerun_types_test.go
index 2e6b667dd47..5c80a181ab2 100644
--- a/pkg/apis/pipeline/v1alpha1/pipelinerun_types_test.go
+++ b/pkg/apis/pipeline/v1alpha1/pipelinerun_types_test.go
@@ -6,18 +6,17 @@ import (
 
 	"github.com/google/go-cmp/cmp"
 	"github.com/knative/pkg/apis"
-	duckv1alpha1 "github.com/knative/pkg/apis/duck/v1alpha1"
 	corev1 "k8s.io/api/core/v1"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 )
 
 func TestPipelineRunStatusConditions(t *testing.T) {
 	p := &PipelineRun{}
-	foo := &duckv1alpha1.Condition{
+	foo := &apis.Condition{
 		Type:   "Foo",
 		Status: "True",
 	}
-	bar := &duckv1alpha1.Condition{
+	bar := &apis.Condition{
 		Type:   "Bar",
 		Status: "True",
 	}
@@ -91,8 +90,8 @@ func TestInitializeConditions(t *testing.T) {
 
 func TestPipelineRunIsDone(t *testing.T) {
 	pr := &PipelineRun{}
-	foo := &duckv1alpha1.Condition{
-		Type:   duckv1alpha1.ConditionSucceeded,
+	foo := &apis.Condition{
+		Type:   apis.ConditionSucceeded,
 		Status: corev1.ConditionFalse,
 	}
 	pr.Status.SetCondition(foo)
diff --git a/pkg/apis/pipeline/v1alpha1/taskrun_types.go b/pkg/apis/pipeline/v1alpha1/taskrun_types.go
index 21ec8c174b5..6a51f153b1f 100644
--- a/pkg/apis/pipeline/v1alpha1/taskrun_types.go
+++ b/pkg/apis/pipeline/v1alpha1/taskrun_types.go
@@ -21,7 +21,7 @@ import (
 	"time"
 
 	"github.com/knative/pkg/apis"
-	duckv1alpha1 "github.com/knative/pkg/apis/duck/v1alpha1"
+	duckv1beta1 "github.com/knative/pkg/apis/duck/v1beta1"
 	corev1 "k8s.io/api/core/v1"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 )
@@ -111,13 +111,11 @@ type TaskTrigger struct {
 	Name string `json:"name,omitempty"`
 }
 
-var taskRunCondSet = duckv1alpha1.NewBatchConditionSet()
+var taskRunCondSet = apis.NewBatchConditionSet()
 
 // TaskRunStatus defines the observed state of TaskRun
 type TaskRunStatus struct {
-	// Conditions describes the set of conditions of this build.
-	// +optional
-	Conditions duckv1alpha1.Conditions `json:"conditions,omitempty"`
+	duckv1beta1.Status `json:",inline"`
 
 	// In #107 should be updated to hold the location logs have been uploaded to
 	// +optional
@@ -140,7 +138,7 @@ type TaskRunStatus struct {
 }
 
 // GetCondition returns the Condition matching the given type.
-func (tr *TaskRunStatus) GetCondition(t duckv1alpha1.ConditionType) *duckv1alpha1.Condition {
+func (tr *TaskRunStatus) GetCondition(t apis.ConditionType) *apis.Condition {
 	return taskRunCondSet.Manage(tr).GetCondition(t)
 }
 func (tr *TaskRunStatus) InitializeConditions() {
@@ -152,7 +150,7 @@ func (tr *TaskRunStatus) InitializeConditions() {
 
 // SetCondition sets the condition, unsetting previous conditions with the same
 // type as necessary.
-func (tr *TaskRunStatus) SetCondition(newCond *duckv1alpha1.Condition) {
+func (tr *TaskRunStatus) SetCondition(newCond *apis.Condition) {
 	if newCond != nil {
 		taskRunCondSet.Manage(tr).SetCondition(*newCond)
 	}
@@ -225,7 +223,7 @@ func (tr *TaskRun) HasPipelineRunOwnerReference() bool {
 
 // IsDone returns true if the TaskRun's status indicates that it is done.
 func (tr *TaskRun) IsDone() bool {
-	return !tr.Status.GetCondition(duckv1alpha1.ConditionSucceeded).IsUnknown()
+	return !tr.Status.GetCondition(apis.ConditionSucceeded).IsUnknown()
 }
 
 // IsCancelled returns true if the TaskRun's spec status is set to Cancelled state
diff --git a/pkg/apis/pipeline/v1alpha1/taskrun_types_test.go b/pkg/apis/pipeline/v1alpha1/taskrun_types_test.go
index adf82001a81..9b194fe5b05 100644
--- a/pkg/apis/pipeline/v1alpha1/taskrun_types_test.go
+++ b/pkg/apis/pipeline/v1alpha1/taskrun_types_test.go
@@ -20,7 +20,7 @@ import (
 	"testing"
 
 	"github.com/google/go-cmp/cmp"
-	duckv1alpha1 "github.com/knative/pkg/apis/duck/v1alpha1"
+	"github.com/knative/pkg/apis"
 	corev1 "k8s.io/api/core/v1"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 )
@@ -129,8 +129,8 @@ func TestTaskRun_HasPipelineRun(t *testing.T) {
 
 func TestTaskRunIsDone(t *testing.T) {
 	tr := &TaskRun{}
-	foo := &duckv1alpha1.Condition{
-		Type:   duckv1alpha1.ConditionSucceeded,
+	foo := &apis.Condition{
+		Type:   apis.ConditionSucceeded,
 		Status: corev1.ConditionFalse,
 	}
 	tr.Status.SetCondition(foo)
diff --git a/pkg/apis/pipeline/v1alpha1/zz_generated.deepcopy.go b/pkg/apis/pipeline/v1alpha1/zz_generated.deepcopy.go
index bbc7d10363d..8c11b735445 100644
--- a/pkg/apis/pipeline/v1alpha1/zz_generated.deepcopy.go
+++ b/pkg/apis/pipeline/v1alpha1/zz_generated.deepcopy.go
@@ -21,7 +21,6 @@ limitations under the License.
 package v1alpha1
 
 import (
-	duck_v1alpha1 "github.com/knative/pkg/apis/duck/v1alpha1"
 	core_v1 "k8s.io/api/core/v1"
 	v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	runtime "k8s.io/apimachinery/pkg/runtime"
@@ -727,13 +726,7 @@ func (in *PipelineRunSpec) DeepCopy() *PipelineRunSpec {
 // DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
 func (in *PipelineRunStatus) DeepCopyInto(out *PipelineRunStatus) {
 	*out = *in
-	if in.Conditions != nil {
-		in, out := &in.Conditions, &out.Conditions
-		*out = make(duck_v1alpha1.Conditions, len(*in))
-		for i := range *in {
-			(*in)[i].DeepCopyInto(&(*out)[i])
-		}
-	}
+	in.Status.DeepCopyInto(&out.Status)
 	if in.Results != nil {
 		in, out := &in.Results, &out.Results
 		if *in == nil {
@@ -1388,13 +1381,7 @@ func (in *TaskRunSpec) DeepCopy() *TaskRunSpec {
 // DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
 func (in *TaskRunStatus) DeepCopyInto(out *TaskRunStatus) {
 	*out = *in
-	if in.Conditions != nil {
-		in, out := &in.Conditions, &out.Conditions
-		*out = make(duck_v1alpha1.Conditions, len(*in))
-		for i := range *in {
-			(*in)[i].DeepCopyInto(&(*out)[i])
-		}
-	}
+	in.Status.DeepCopyInto(&out.Status)
 	if in.Results != nil {
 		in, out := &in.Results, &out.Results
 		if *in == nil {
diff --git a/pkg/reconciler/event.go b/pkg/reconciler/event.go
index 8f8638632a9..9be89340db2 100644
--- a/pkg/reconciler/event.go
+++ b/pkg/reconciler/event.go
@@ -16,7 +16,7 @@ limitations under the License.
 package reconciler
 
 import (
-	duckv1alpha1 "github.com/knative/pkg/apis/duck/v1alpha1"
+	"github.com/knative/pkg/apis"
 	corev1 "k8s.io/api/core/v1"
 	"k8s.io/apimachinery/pkg/runtime"
 	"k8s.io/client-go/tools/record"
@@ -24,7 +24,7 @@ import (
 
 // EmitEvent emits success or failed event for object
 // if afterCondition is different from beforeCondition
-func EmitEvent(c record.EventRecorder, beforeCondition *duckv1alpha1.Condition, afterCondition *duckv1alpha1.Condition, object runtime.Object) {
+func EmitEvent(c record.EventRecorder, beforeCondition *apis.Condition, afterCondition *apis.Condition, object runtime.Object) {
 	if beforeCondition != afterCondition && afterCondition != nil {
 		// Create events when the obj result is in.
 		if afterCondition.Status == corev1.ConditionTrue {
diff --git a/pkg/reconciler/event_test.go b/pkg/reconciler/event_test.go
index 04fae93a77c..439efe1bf92 100644
--- a/pkg/reconciler/event_test.go
+++ b/pkg/reconciler/event_test.go
@@ -4,7 +4,7 @@ import (
 	"testing"
 	"time"
 
-	duckv1alpha1 "github.com/knative/pkg/apis/duck/v1alpha1"
+	"github.com/knative/pkg/apis"
 	corev1 "k8s.io/api/core/v1"
 	"k8s.io/client-go/tools/record"
 )
@@ -12,42 +12,42 @@ import (
 func Test_EmitEvent(t *testing.T) {
 	testcases := []struct {
 		name        string
-		before      *duckv1alpha1.Condition
-		after       *duckv1alpha1.Condition
+		before      *apis.Condition
+		after       *apis.Condition
 		expectEvent bool
 	}{
 		{
 			name: "unknown to true",
-			before: &duckv1alpha1.Condition{
-				Type:   duckv1alpha1.ConditionSucceeded,
+			before: &apis.Condition{
+				Type:   apis.ConditionSucceeded,
 				Status: corev1.ConditionUnknown,
 			},
-			after: &duckv1alpha1.Condition{
-				Type:   duckv1alpha1.ConditionSucceeded,
+			after: &apis.Condition{
+				Type:   apis.ConditionSucceeded,
 				Status: corev1.ConditionTrue,
 			},
 			expectEvent: true,
 		},
 		{
 			name: "true to true",
-			before: &duckv1alpha1.Condition{
-				Type:   duckv1alpha1.ConditionSucceeded,
+			before: &apis.Condition{
+				Type:   apis.ConditionSucceeded,
 				Status: corev1.ConditionTrue,
 			},
-			after: &duckv1alpha1.Condition{
-				Type:   duckv1alpha1.ConditionSucceeded,
+			after: &apis.Condition{
+				Type:   apis.ConditionSucceeded,
 				Status: corev1.ConditionTrue,
 			},
 			expectEvent: false,
 		},
 		{
 			name: "false to false",
-			before: &duckv1alpha1.Condition{
-				Type:   duckv1alpha1.ConditionSucceeded,
+			before: &apis.Condition{
+				Type:   apis.ConditionSucceeded,
 				Status: corev1.ConditionFalse,
 			},
-			after: &duckv1alpha1.Condition{
-				Type:   duckv1alpha1.ConditionSucceeded,
+			after: &apis.Condition{
+				Type:   apis.ConditionSucceeded,
 				Status: corev1.ConditionFalse,
 			},
 			expectEvent: false,
@@ -55,8 +55,8 @@ func Test_EmitEvent(t *testing.T) {
 		{
 			name:  "true to nil",
 			after: nil,
-			before: &duckv1alpha1.Condition{
-				Type:   duckv1alpha1.ConditionSucceeded,
+			before: &apis.Condition{
+				Type:   apis.ConditionSucceeded,
 				Status: corev1.ConditionTrue,
 			},
 			expectEvent: true,
@@ -64,8 +64,8 @@ func Test_EmitEvent(t *testing.T) {
 		{
 			name:   "nil to true",
 			before: nil,
-			after: &duckv1alpha1.Condition{
-				Type:   duckv1alpha1.ConditionSucceeded,
+			after: &apis.Condition{
+				Type:   apis.ConditionSucceeded,
 				Status: corev1.ConditionTrue,
 			},
 			expectEvent: true,
diff --git a/pkg/reconciler/reconciler_test.go b/pkg/reconciler/reconciler_test.go
index 48f72baafdd..f1c31e63564 100644
--- a/pkg/reconciler/reconciler_test.go
+++ b/pkg/reconciler/reconciler_test.go
@@ -21,7 +21,7 @@ import (
 	"strings"
 	"testing"
 
-	duckv1alpha1 "github.com/knative/pkg/apis/duck/v1alpha1"
+	"github.com/knative/pkg/apis"
 	"github.com/tektoncd/pipeline/pkg/apis/pipeline/v1alpha1"
 	"github.com/tektoncd/pipeline/pkg/reconciler/v1alpha1/pipelinerun/resources"
 	"github.com/tektoncd/pipeline/test"
@@ -37,8 +37,8 @@ func TestRecorderOptions(t *testing.T) {
 
 	prs := []*v1alpha1.PipelineRun{tb.PipelineRun("test-pipeline-run-completed", "foo",
 		tb.PipelineRunSpec("test-pipeline", tb.PipelineRunServiceAccount("test-sa")),
-		tb.PipelineRunStatus(tb.PipelineRunStatusCondition(duckv1alpha1.Condition{
-			Type:    duckv1alpha1.ConditionSucceeded,
+		tb.PipelineRunStatus(tb.PipelineRunStatusCondition(apis.Condition{
+			Type:    apis.ConditionSucceeded,
 			Status:  corev1.ConditionTrue,
 			Reason:  resources.ReasonSucceeded,
 			Message: "All Tasks have completed executing",
diff --git a/pkg/reconciler/timeout_handler_test.go b/pkg/reconciler/timeout_handler_test.go
index 8565e66c8be..7024a8ed391 100644
--- a/pkg/reconciler/timeout_handler_test.go
+++ b/pkg/reconciler/timeout_handler_test.go
@@ -6,17 +6,15 @@ import (
 	"testing"
 	"time"
 
-	"go.uber.org/zap"
-	"go.uber.org/zap/zaptest/observer"
-	"k8s.io/apimachinery/pkg/util/wait"
-
-	duckv1alpha1 "github.com/knative/pkg/apis/duck/v1alpha1"
+	"github.com/knative/pkg/apis"
 	"github.com/tektoncd/pipeline/pkg/apis/pipeline/v1alpha1"
 	"github.com/tektoncd/pipeline/test"
 	tb "github.com/tektoncd/pipeline/test/builder"
+	"go.uber.org/zap"
+	"go.uber.org/zap/zaptest/observer"
 	corev1 "k8s.io/api/core/v1"
-
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/apimachinery/pkg/util/wait"
 )
 
 var (
@@ -29,32 +27,32 @@ func TestTaskRunCheckTimeouts(t *testing.T) {
 	taskRunTimedout := tb.TaskRun("test-taskrun-run-timedout", testNs, tb.TaskRunSpec(
 		tb.TaskRunTaskRef(simpleTask.Name, tb.TaskRefAPIVersion("a1")),
 		tb.TaskRunTimeout(1*time.Second),
-	), tb.TaskRunStatus(tb.Condition(duckv1alpha1.Condition{
-		Type:   duckv1alpha1.ConditionSucceeded,
+	), tb.TaskRunStatus(tb.Condition(apis.Condition{
+		Type:   apis.ConditionSucceeded,
 		Status: corev1.ConditionUnknown}),
 		tb.TaskRunStartTime(time.Now().Add(-10*time.Second)),
 	))
 
 	taskRunRunning := tb.TaskRun("test-taskrun-running", testNs, tb.TaskRunSpec(
 		tb.TaskRunTaskRef(simpleTask.Name, tb.TaskRefAPIVersion("a1")),
-	), tb.TaskRunStatus(tb.Condition(duckv1alpha1.Condition{
-		Type:   duckv1alpha1.ConditionSucceeded,
+	), tb.TaskRunStatus(tb.Condition(apis.Condition{
+		Type:   apis.ConditionSucceeded,
 		Status: corev1.ConditionUnknown}),
 		tb.TaskRunStartTime(time.Now()),
 	))
 
 	taskRunDone := tb.TaskRun("test-taskrun-completed", testNs, tb.TaskRunSpec(
 		tb.TaskRunTaskRef(simpleTask.Name, tb.TaskRefAPIVersion("a1")),
-	), tb.TaskRunStatus(tb.Condition(duckv1alpha1.Condition{
-		Type:   duckv1alpha1.ConditionSucceeded,
+	), tb.TaskRunStatus(tb.Condition(apis.Condition{
+		Type:   apis.ConditionSucceeded,
 		Status: corev1.ConditionTrue}),
 	))
 
 	taskRunCancelled := tb.TaskRun("test-taskrun-run-cancelled", testNs, tb.TaskRunSpec(
 		tb.TaskRunTaskRef(simpleTask.Name),
 		tb.TaskRunCancelled,
-	), tb.TaskRunStatus(tb.Condition(duckv1alpha1.Condition{
-		Type:   duckv1alpha1.ConditionSucceeded,
+	), tb.TaskRunStatus(tb.Condition(apis.Condition{
+		Type:   apis.ConditionSucceeded,
 		Status: corev1.ConditionUnknown}),
 	))
 
@@ -139,16 +137,16 @@ func TestPipelinRunCheckTimeouts(t *testing.T) {
 
 	prRunning := tb.PipelineRun("test-pipeline-running", testNs,
 		tb.PipelineRunSpec("test-pipeline"),
-		tb.PipelineRunStatus(tb.PipelineRunStatusCondition(duckv1alpha1.Condition{
-			Type:   duckv1alpha1.ConditionSucceeded,
+		tb.PipelineRunStatus(tb.PipelineRunStatusCondition(apis.Condition{
+			Type:   apis.ConditionSucceeded,
 			Status: corev1.ConditionUnknown}),
 			tb.PipelineRunStartTime(time.Now()),
 		),
 	)
 	prDone := tb.PipelineRun("test-pipeline-done", testNs,
 		tb.PipelineRunSpec("test-pipeline"),
-		tb.PipelineRunStatus(tb.PipelineRunStatusCondition(duckv1alpha1.Condition{
-			Type:   duckv1alpha1.ConditionSucceeded,
+		tb.PipelineRunStatus(tb.PipelineRunStatusCondition(apis.Condition{
+			Type:   apis.ConditionSucceeded,
 			Status: corev1.ConditionTrue}),
 		),
 	)
@@ -156,8 +154,8 @@ func TestPipelinRunCheckTimeouts(t *testing.T) {
 		tb.PipelineRunSpec("test-pipeline", tb.PipelineRunServiceAccount("test-sa"),
 			tb.PipelineRunCancelled,
 		),
-		tb.PipelineRunStatus(tb.PipelineRunStatusCondition(duckv1alpha1.Condition{
-			Type:   duckv1alpha1.ConditionSucceeded,
+		tb.PipelineRunStatus(tb.PipelineRunStatusCondition(apis.Condition{
+			Type:   apis.ConditionSucceeded,
 			Status: corev1.ConditionUnknown}),
 		),
 	)
@@ -231,8 +229,8 @@ func TestWithNoFunc(t *testing.T) {
 	taskRunRunning := tb.TaskRun("test-taskrun-running", testNs, tb.TaskRunSpec(
 		tb.TaskRunTaskRef(simpleTask.Name, tb.TaskRefAPIVersion("a1")),
 		tb.TaskRunTimeout(2*time.Second),
-	), tb.TaskRunStatus(tb.Condition(duckv1alpha1.Condition{
-		Type:   duckv1alpha1.ConditionSucceeded,
+	), tb.TaskRunStatus(tb.Condition(apis.Condition{
+		Type:   apis.ConditionSucceeded,
 		Status: corev1.ConditionUnknown}),
 		tb.TaskRunStartTime(time.Now().Add(-10*time.Second)),
 	))
diff --git a/pkg/reconciler/v1alpha1/pipelinerun/cancel.go b/pkg/reconciler/v1alpha1/pipelinerun/cancel.go
index 84b43de5230..3f6710f689a 100644
--- a/pkg/reconciler/v1alpha1/pipelinerun/cancel.go
+++ b/pkg/reconciler/v1alpha1/pipelinerun/cancel.go
@@ -20,7 +20,7 @@ import (
 	"fmt"
 	"strings"
 
-	duckv1alpha1 "github.com/knative/pkg/apis/duck/v1alpha1"
+	"github.com/knative/pkg/apis"
 	"github.com/tektoncd/pipeline/pkg/apis/pipeline/v1alpha1"
 	clientset "github.com/tektoncd/pipeline/pkg/client/clientset/versioned"
 	"github.com/tektoncd/pipeline/pkg/reconciler/v1alpha1/pipelinerun/resources"
@@ -29,8 +29,8 @@ import (
 
 // cancelPipelineRun makrs the PipelineRun as cancelled and any resolved taskrun too.
 func cancelPipelineRun(pr *v1alpha1.PipelineRun, pipelineState []*resources.ResolvedPipelineRunTask, clientSet clientset.Interface) error {
-	pr.Status.SetCondition(&duckv1alpha1.Condition{
-		Type:    duckv1alpha1.ConditionSucceeded,
+	pr.Status.SetCondition(&apis.Condition{
+		Type:    apis.ConditionSucceeded,
 		Status:  corev1.ConditionFalse,
 		Reason:  "PipelineRunCancelled",
 		Message: fmt.Sprintf("PipelineRun %q was cancelled", pr.Name),
diff --git a/pkg/reconciler/v1alpha1/pipelinerun/cancel_test.go b/pkg/reconciler/v1alpha1/pipelinerun/cancel_test.go
index 72e781a601f..38bf13b270e 100644
--- a/pkg/reconciler/v1alpha1/pipelinerun/cancel_test.go
+++ b/pkg/reconciler/v1alpha1/pipelinerun/cancel_test.go
@@ -19,7 +19,7 @@ package pipelinerun
 import (
 	"testing"
 
-	duckv1alpha1 "github.com/knative/pkg/apis/duck/v1alpha1"
+	"github.com/knative/pkg/apis"
 	"github.com/tektoncd/pipeline/pkg/apis/pipeline/v1alpha1"
 	"github.com/tektoncd/pipeline/pkg/reconciler/v1alpha1/pipelinerun/resources"
 	"github.com/tektoncd/pipeline/test"
@@ -78,7 +78,7 @@ func TestCancelPipelineRun(t *testing.T) {
 				t.Fatal(err)
 			}
 			// This PipelineRun should still be complete and false, and the status should reflect that
-			cond := tc.pipelineRun.Status.GetCondition(duckv1alpha1.ConditionSucceeded)
+			cond := tc.pipelineRun.Status.GetCondition(apis.ConditionSucceeded)
 			if cond.IsTrue() {
 				t.Errorf("Expected PipelineRun status to be complete and false, but was %v", cond)
 			}
diff --git a/pkg/reconciler/v1alpha1/pipelinerun/pipelinerun.go b/pkg/reconciler/v1alpha1/pipelinerun/pipelinerun.go
index 2362ae9cab0..eeae600109f 100644
--- a/pkg/reconciler/v1alpha1/pipelinerun/pipelinerun.go
+++ b/pkg/reconciler/v1alpha1/pipelinerun/pipelinerun.go
@@ -22,7 +22,7 @@ import (
 	"reflect"
 	"time"
 
-	duckv1alpha1 "github.com/knative/pkg/apis/duck/v1alpha1"
+	"github.com/knative/pkg/apis"
 	"github.com/knative/pkg/configmap"
 	"github.com/knative/pkg/controller"
 	"github.com/knative/pkg/tracker"
@@ -219,8 +219,8 @@ func (c *Reconciler) reconcile(ctx context.Context, pr *v1alpha1.PipelineRun) er
 	p, err := c.pipelineLister.Pipelines(pr.Namespace).Get(pr.Spec.PipelineRef.Name)
 	if err != nil {
 		// This Run has failed, so we need to mark it as failed and stop reconciling it
-		pr.Status.SetCondition(&duckv1alpha1.Condition{
-			Type:   duckv1alpha1.ConditionSucceeded,
+		pr.Status.SetCondition(&apis.Condition{
+			Type:   apis.ConditionSucceeded,
 			Status: corev1.ConditionFalse,
 			Reason: ReasonCouldntGetPipeline,
 			Message: fmt.Sprintf("Pipeline %s can't be found:%s",
@@ -234,8 +234,8 @@ func (c *Reconciler) reconcile(ctx context.Context, pr *v1alpha1.PipelineRun) er
 	d, err := v1alpha1.BuildDAG(p.Spec.Tasks)
 	if err != nil {
 		// This Run has failed, so we need to mark it as failed and stop reconciling it
-		pr.Status.SetCondition(&duckv1alpha1.Condition{
-			Type:   duckv1alpha1.ConditionSucceeded,
+		pr.Status.SetCondition(&apis.Condition{
+			Type:   apis.ConditionSucceeded,
 			Status: corev1.ConditionFalse,
 			Reason: ReasonInvalidGraph,
 			Message: fmt.Sprintf("PipelineRun %s's Pipeline DAG is invalid: %s",
@@ -246,8 +246,8 @@ func (c *Reconciler) reconcile(ctx context.Context, pr *v1alpha1.PipelineRun) er
 	providedResources, err := resources.GetResourcesFromBindings(p, pr)
 	if err != nil {
 		// This Run has failed, so we need to mark it as failed and stop reconciling it
-		pr.Status.SetCondition(&duckv1alpha1.Condition{
-			Type:   duckv1alpha1.ConditionSucceeded,
+		pr.Status.SetCondition(&apis.Condition{
+			Type:   apis.ConditionSucceeded,
 			Status: corev1.ConditionFalse,
 			Reason: ReasonInvalidBindings,
 			Message: fmt.Sprintf("PipelineRun %s doesn't bind Pipeline %s's PipelineResources correctly: %s",
@@ -283,24 +283,24 @@ func (c *Reconciler) reconcile(ctx context.Context, pr *v1alpha1.PipelineRun) er
 		// This Run has failed, so we need to mark it as failed and stop reconciling it
 		switch err := err.(type) {
 		case *resources.TaskNotFoundError:
-			pr.Status.SetCondition(&duckv1alpha1.Condition{
-				Type:   duckv1alpha1.ConditionSucceeded,
+			pr.Status.SetCondition(&apis.Condition{
+				Type:   apis.ConditionSucceeded,
 				Status: corev1.ConditionFalse,
 				Reason: ReasonCouldntGetTask,
 				Message: fmt.Sprintf("Pipeline %s can't be Run; it contains Tasks that don't exist: %s",
 					fmt.Sprintf("%s/%s", p.Namespace, p.Name), err),
 			})
 		case *resources.ResourceNotFoundError:
-			pr.Status.SetCondition(&duckv1alpha1.Condition{
-				Type:   duckv1alpha1.ConditionSucceeded,
+			pr.Status.SetCondition(&apis.Condition{
+				Type:   apis.ConditionSucceeded,
 				Status: corev1.ConditionFalse,
 				Reason: ReasonCouldntGetResource,
 				Message: fmt.Sprintf("PipelineRun %s can't be Run; it tries to bind Resources that don't exist: %s",
 					fmt.Sprintf("%s/%s", p.Namespace, pr.Name), err),
 			})
 		default:
-			pr.Status.SetCondition(&duckv1alpha1.Condition{
-				Type:   duckv1alpha1.ConditionSucceeded,
+			pr.Status.SetCondition(&apis.Condition{
+				Type:   apis.ConditionSucceeded,
 				Status: corev1.ConditionFalse,
 				Reason: ReasonFailedValidation,
 				Message: fmt.Sprintf("PipelineRun %s can't be Run; couldn't resolve all references: %s",
@@ -311,8 +311,8 @@ func (c *Reconciler) reconcile(ctx context.Context, pr *v1alpha1.PipelineRun) er
 	}
 	if err := resources.ValidateFrom(pipelineState); err != nil {
 		// This Run has failed, so we need to mark it as failed and stop reconciling it
-		pr.Status.SetCondition(&duckv1alpha1.Condition{
-			Type:   duckv1alpha1.ConditionSucceeded,
+		pr.Status.SetCondition(&apis.Condition{
+			Type:   apis.ConditionSucceeded,
 			Status: corev1.ConditionFalse,
 			Reason: ReasonFailedValidation,
 			Message: fmt.Sprintf("Pipeline %s can't be Run; it invalid input/output linkages: %s",
@@ -325,8 +325,8 @@ func (c *Reconciler) reconcile(ctx context.Context, pr *v1alpha1.PipelineRun) er
 		err := taskrun.ValidateResolvedTaskResources(rprt.PipelineTask.Params, rprt.ResolvedTaskResources)
 		if err != nil {
 			c.Logger.Errorf("Failed to validate pipelinerun %q with error %v", pr.Name, err)
-			pr.Status.SetCondition(&duckv1alpha1.Condition{
-				Type:    duckv1alpha1.ConditionSucceeded,
+			pr.Status.SetCondition(&apis.Condition{
+				Type:    apis.ConditionSucceeded,
 				Status:  corev1.ConditionFalse,
 				Reason:  ReasonFailedValidation,
 				Message: err.Error(),
@@ -367,7 +367,7 @@ func (c *Reconciler) reconcile(ctx context.Context, pr *v1alpha1.PipelineRun) er
 			}
 		}
 	}
-	before := pr.Status.GetCondition(duckv1alpha1.ConditionSucceeded)
+	before := pr.Status.GetCondition(apis.ConditionSucceeded)
 	c.timeoutHandler.StatusLock(pr)
 	after := resources.GetPipelineConditionStatus(pr.Name, pipelineState, c.Logger, pr.Status.StartTime, pr.Spec.Timeout)
 
@@ -377,7 +377,7 @@ func (c *Reconciler) reconcile(ctx context.Context, pr *v1alpha1.PipelineRun) er
 
 	updateTaskRunsStatus(pr, pipelineState)
 
-	c.Logger.Infof("PipelineRun %s status is being set to %s", pr.Name, pr.Status.GetCondition(duckv1alpha1.ConditionSucceeded))
+	c.Logger.Infof("PipelineRun %s status is being set to %s", pr.Name, pr.Status.GetCondition(apis.ConditionSucceeded))
 	return nil
 }
 
diff --git a/pkg/reconciler/v1alpha1/pipelinerun/pipelinerun_test.go b/pkg/reconciler/v1alpha1/pipelinerun/pipelinerun_test.go
index da7bcc2d390..2e606e0e7a0 100644
--- a/pkg/reconciler/v1alpha1/pipelinerun/pipelinerun_test.go
+++ b/pkg/reconciler/v1alpha1/pipelinerun/pipelinerun_test.go
@@ -21,7 +21,8 @@ import (
 
 	"github.com/google/go-cmp/cmp"
 	"github.com/google/go-cmp/cmp/cmpopts"
-	duckv1alpha1 "github.com/knative/pkg/apis/duck/v1alpha1"
+	"github.com/knative/pkg/apis"
+	duckv1beta1 "github.com/knative/pkg/apis/duck/v1beta1"
 	"github.com/knative/pkg/configmap"
 	"github.com/tektoncd/pipeline/pkg/apis/pipeline"
 	"github.com/tektoncd/pipeline/pkg/apis/pipeline/v1alpha1"
@@ -239,7 +240,7 @@ func TestReconcile(t *testing.T) {
 	}
 
 	// This PipelineRun is in progress now and the status should reflect that
-	condition := reconciledRun.Status.GetCondition(duckv1alpha1.ConditionSucceeded)
+	condition := reconciledRun.Status.GetCondition(apis.ConditionSucceeded)
 	if condition == nil || condition.Status != corev1.ConditionUnknown {
 		t.Errorf("Expected PipelineRun status to be in progress, but was %v", condition)
 	}
@@ -341,7 +342,7 @@ func TestReconcile_InvalidPipelineRuns(t *testing.T) {
 			validateNoEvents(t, fr)
 
 			// Since the PipelineRun is invalid, the status should say it has failed
-			condition := tc.pipelineRun.Status.GetCondition(duckv1alpha1.ConditionSucceeded)
+			condition := tc.pipelineRun.Status.GetCondition(apis.ConditionSucceeded)
 			if condition == nil || condition.Status != corev1.ConditionFalse {
 				t.Errorf("Expected status to be failed on invalid PipelineRun but was: %v", condition)
 			}
@@ -408,7 +409,7 @@ func TestUpdateTaskRunsState(t *testing.T) {
 		tb.TaskRunTaskRef("unit-test-task"),
 		tb.TaskRunServiceAccount("test-sa"),
 	), tb.TaskRunStatus(
-		tb.Condition(duckv1alpha1.Condition{Type: duckv1alpha1.ConditionSucceeded}),
+		tb.Condition(apis.Condition{Type: apis.ConditionSucceeded}),
 		tb.StepState(tb.StateTerminated(0)),
 	))
 
@@ -421,9 +422,9 @@ func TestUpdateTaskRunsState(t *testing.T) {
 					Terminated: &corev1.ContainerStateTerminated{ExitCode: 0},
 				},
 			}},
-			Conditions: []duckv1alpha1.Condition{{
-				Type: duckv1alpha1.ConditionSucceeded,
-			}},
+			Status: duckv1beta1.Status{
+				Conditions: []apis.Condition{{Type: apis.ConditionSucceeded}},
+			},
 		},
 	}
 	expectedPipelineRunStatus := v1alpha1.PipelineRunStatus{
@@ -449,8 +450,8 @@ func TestUpdateTaskRunsState(t *testing.T) {
 func TestReconcileOnCompletedPipelineRun(t *testing.T) {
 	prs := []*v1alpha1.PipelineRun{tb.PipelineRun("test-pipeline-run-completed", "foo",
 		tb.PipelineRunSpec("test-pipeline", tb.PipelineRunServiceAccount("test-sa")),
-		tb.PipelineRunStatus(tb.PipelineRunStatusCondition(duckv1alpha1.Condition{
-			Type:    duckv1alpha1.ConditionSucceeded,
+		tb.PipelineRunStatus(tb.PipelineRunStatusCondition(apis.Condition{
+			Type:    apis.ConditionSucceeded,
 			Status:  corev1.ConditionTrue,
 			Reason:  resources.ReasonSucceeded,
 			Message: "All Tasks have completed executing",
@@ -488,8 +489,8 @@ func TestReconcileOnCompletedPipelineRun(t *testing.T) {
 	}
 
 	// This PipelineRun should still be complete and the status should reflect that
-	if reconciledRun.Status.GetCondition(duckv1alpha1.ConditionSucceeded).IsUnknown() {
-		t.Errorf("Expected PipelineRun status to be complete, but was %v", reconciledRun.Status.GetCondition(duckv1alpha1.ConditionSucceeded))
+	if reconciledRun.Status.GetCondition(apis.ConditionSucceeded).IsUnknown() {
+		t.Errorf("Expected PipelineRun status to be complete, but was %v", reconciledRun.Status.GetCondition(apis.ConditionSucceeded))
 	}
 }
 
@@ -563,8 +564,8 @@ func TestReconcileOnCancelledPipelineRun(t *testing.T) {
 	reconciledRun, err := clients.Pipeline.Tekton().PipelineRuns("foo").Get("test-pipeline-run-cancelled", metav1.GetOptions{})
 
 	// This PipelineRun should still be complete and false, and the status should reflect that
-	if !reconciledRun.Status.GetCondition(duckv1alpha1.ConditionSucceeded).IsFalse() {
-		t.Errorf("Expected PipelineRun status to be complete and false, but was %v", reconciledRun.Status.GetCondition(duckv1alpha1.ConditionSucceeded))
+	if !reconciledRun.Status.GetCondition(apis.ConditionSucceeded).IsFalse() {
+		t.Errorf("Expected PipelineRun status to be complete and false, but was %v", reconciledRun.Status.GetCondition(apis.ConditionSucceeded))
 	}
 }
 
@@ -607,8 +608,8 @@ func TestReconcileWithTimeout(t *testing.T) {
 	}
 
 	// The PipelineRun should be timed out.
-	if reconciledRun.Status.GetCondition(duckv1alpha1.ConditionSucceeded).Reason != resources.ReasonTimedOut {
-		t.Errorf("Expected PipelineRun to be timed out, but condition reason is %s", reconciledRun.Status.GetCondition(duckv1alpha1.ConditionSucceeded))
+	if reconciledRun.Status.GetCondition(apis.ConditionSucceeded).Reason != resources.ReasonTimedOut {
+		t.Errorf("Expected PipelineRun to be timed out, but condition reason is %s", reconciledRun.Status.GetCondition(apis.ConditionSucceeded))
 	}
 
 	// Check that the expected TaskRun was created
diff --git a/pkg/reconciler/v1alpha1/pipelinerun/resources/pipelinerunresolution.go b/pkg/reconciler/v1alpha1/pipelinerun/resources/pipelinerunresolution.go
index b416a79f7ff..c3d587f36b0 100644
--- a/pkg/reconciler/v1alpha1/pipelinerun/resources/pipelinerunresolution.go
+++ b/pkg/reconciler/v1alpha1/pipelinerun/resources/pipelinerunresolution.go
@@ -20,7 +20,7 @@ import (
 	"fmt"
 	"time"
 
-	duckv1alpha1 "github.com/knative/pkg/apis/duck/v1alpha1"
+	"github.com/knative/pkg/apis"
 	"github.com/tektoncd/pipeline/pkg/names"
 	"go.uber.org/zap"
 	corev1 "k8s.io/api/core/v1"
@@ -80,7 +80,7 @@ func (state PipelineRunState) SuccessfulPipelineTaskNames() []string {
 	done := []string{}
 	for _, t := range state {
 		if t.TaskRun != nil {
-			c := t.TaskRun.Status.GetCondition(duckv1alpha1.ConditionSucceeded)
+			c := t.TaskRun.Status.GetCondition(apis.ConditionSucceeded)
 			if c.IsTrue() {
 				done = append(done, t.PipelineTask.Name)
 			}
@@ -252,7 +252,7 @@ func getTaskRunName(taskRunsStatus map[string]*v1alpha1.PipelineRunTaskRunStatus
 // GetPipelineConditionStatus will return the Condition that the PipelineRun prName should be
 // updated with, based on the status of the TaskRuns in state.
 func GetPipelineConditionStatus(prName string, state PipelineRunState, logger *zap.SugaredLogger, startTime *metav1.Time,
-	pipelineTimeout *metav1.Duration) *duckv1alpha1.Condition {
+	pipelineTimeout *metav1.Duration) *apis.Condition {
 	allFinished := true
 	if !startTime.IsZero() && pipelineTimeout != nil {
 		timeout := pipelineTimeout.Duration
@@ -261,8 +261,8 @@ func GetPipelineConditionStatus(prName string, state PipelineRunState, logger *z
 			logger.Infof("PipelineRun %q has timed out(runtime %s over %s)", prName, runtime, timeout)
 
 			timeoutMsg := fmt.Sprintf("PipelineRun %q failed to finish within %q", prName, timeout.String())
-			return &duckv1alpha1.Condition{
-				Type:    duckv1alpha1.ConditionSucceeded,
+			return &apis.Condition{
+				Type:    apis.ConditionSucceeded,
 				Status:  corev1.ConditionFalse,
 				Reason:  ReasonTimedOut,
 				Message: timeoutMsg,
@@ -275,7 +275,7 @@ func GetPipelineConditionStatus(prName string, state PipelineRunState, logger *z
 			allFinished = false
 			continue
 		}
-		c := rprt.TaskRun.Status.GetCondition(duckv1alpha1.ConditionSucceeded)
+		c := rprt.TaskRun.Status.GetCondition(apis.ConditionSucceeded)
 		if c == nil {
 			logger.Infof("TaskRun %s doesn't have a condition, so PipelineRun %s isn't finished", rprt.TaskRunName, prName)
 			allFinished = false
@@ -285,8 +285,8 @@ func GetPipelineConditionStatus(prName string, state PipelineRunState, logger *z
 		// If any TaskRuns have failed, we should halt execution and consider the run failed
 		if c.Status == corev1.ConditionFalse {
 			logger.Infof("TaskRun %s has failed, so PipelineRun %s has failed", rprt.TaskRunName, prName)
-			return &duckv1alpha1.Condition{
-				Type:    duckv1alpha1.ConditionSucceeded,
+			return &apis.Condition{
+				Type:    apis.ConditionSucceeded,
 				Status:  corev1.ConditionFalse,
 				Reason:  ReasonFailed,
 				Message: fmt.Sprintf("TaskRun %s has failed", rprt.TaskRun.Name),
@@ -299,16 +299,16 @@ func GetPipelineConditionStatus(prName string, state PipelineRunState, logger *z
 	}
 	if !allFinished {
 		logger.Infof("PipelineRun %s still has running TaskRuns so it isn't yet done", prName)
-		return &duckv1alpha1.Condition{
-			Type:    duckv1alpha1.ConditionSucceeded,
+		return &apis.Condition{
+			Type:    apis.ConditionSucceeded,
 			Status:  corev1.ConditionUnknown,
 			Reason:  ReasonRunning,
 			Message: "Not all Tasks in the Pipeline have finished executing",
 		}
 	}
 	logger.Infof("All TaskRuns have finished for PipelineRun %s so it has finished", prName)
-	return &duckv1alpha1.Condition{
-		Type:    duckv1alpha1.ConditionSucceeded,
+	return &apis.Condition{
+		Type:    apis.ConditionSucceeded,
 		Status:  corev1.ConditionTrue,
 		Reason:  ReasonSucceeded,
 		Message: "All Tasks have completed executing",
diff --git a/pkg/reconciler/v1alpha1/pipelinerun/resources/pipelinerunresolution_test.go b/pkg/reconciler/v1alpha1/pipelinerun/resources/pipelinerunresolution_test.go
index a05b93b74c9..0f429a23bee 100644
--- a/pkg/reconciler/v1alpha1/pipelinerun/resources/pipelinerunresolution_test.go
+++ b/pkg/reconciler/v1alpha1/pipelinerun/resources/pipelinerunresolution_test.go
@@ -24,14 +24,14 @@ import (
 
 	"github.com/google/go-cmp/cmp"
 	"github.com/google/go-cmp/cmp/cmpopts"
-	duckv1alpha1 "github.com/knative/pkg/apis/duck/v1alpha1"
-	"go.uber.org/zap"
-	corev1 "k8s.io/api/core/v1"
-
+	"github.com/knative/pkg/apis"
+	duckv1beta1 "github.com/knative/pkg/apis/duck/v1beta1"
 	"github.com/tektoncd/pipeline/pkg/apis/pipeline/v1alpha1"
 	"github.com/tektoncd/pipeline/pkg/reconciler/v1alpha1/taskrun/resources"
 	tb "github.com/tektoncd/pipeline/test/builder"
 	"github.com/tektoncd/pipeline/test/names"
+	"go.uber.org/zap"
+	corev1 "k8s.io/api/core/v1"
 	"k8s.io/apimachinery/pkg/api/errors"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 )
@@ -123,9 +123,9 @@ func newTaskRun(tr v1alpha1.TaskRun) *v1alpha1.TaskRun {
 		},
 		Spec: tr.Spec,
 		Status: v1alpha1.TaskRunStatus{
-			Conditions: []duckv1alpha1.Condition{{
-				Type: duckv1alpha1.ConditionSucceeded,
-			}},
+			Status: duckv1beta1.Status{
+				Conditions: []apis.Condition{{Type: apis.ConditionSucceeded}},
+			},
 		},
 	}
 }
diff --git a/pkg/reconciler/v1alpha1/taskrun/cancel.go b/pkg/reconciler/v1alpha1/taskrun/cancel.go
index 4941ac939d4..8e37e1aea86 100644
--- a/pkg/reconciler/v1alpha1/taskrun/cancel.go
+++ b/pkg/reconciler/v1alpha1/taskrun/cancel.go
@@ -19,7 +19,7 @@ package taskrun
 import (
 	"fmt"
 
-	duckv1alpha1 "github.com/knative/pkg/apis/duck/v1alpha1"
+	"github.com/knative/pkg/apis"
 	"github.com/tektoncd/pipeline/pkg/apis/pipeline/v1alpha1"
 	corev1 "k8s.io/api/core/v1"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
@@ -34,8 +34,8 @@ type logger interface {
 // cancelTaskRun marks the TaskRun as cancelled and delete pods linked to it.
 func cancelTaskRun(tr *v1alpha1.TaskRun, clientSet kubernetes.Interface, logger logger) error {
 	logger.Warn("task run %q has been cancelled", tr.Name)
-	tr.Status.SetCondition(&duckv1alpha1.Condition{
-		Type:    duckv1alpha1.ConditionSucceeded,
+	tr.Status.SetCondition(&apis.Condition{
+		Type:    apis.ConditionSucceeded,
 		Status:  corev1.ConditionFalse,
 		Reason:  "TaskRunCancelled",
 		Message: fmt.Sprintf("TaskRun %q was cancelled", tr.Name),
diff --git a/pkg/reconciler/v1alpha1/taskrun/cancel_test.go b/pkg/reconciler/v1alpha1/taskrun/cancel_test.go
index 1da06ee83df..a89c9e88a03 100644
--- a/pkg/reconciler/v1alpha1/taskrun/cancel_test.go
+++ b/pkg/reconciler/v1alpha1/taskrun/cancel_test.go
@@ -20,7 +20,7 @@ import (
 	"testing"
 
 	"github.com/google/go-cmp/cmp"
-	duckv1alpha1 "github.com/knative/pkg/apis/duck/v1alpha1"
+	"github.com/knative/pkg/apis"
 	"github.com/tektoncd/pipeline/pkg/apis/pipeline/v1alpha1"
 	"github.com/tektoncd/pipeline/test"
 	tb "github.com/tektoncd/pipeline/test/builder"
@@ -35,18 +35,18 @@ func TestCancelTaskRun(t *testing.T) {
 		name           string
 		taskRun        *v1alpha1.TaskRun
 		pod            *corev1.Pod
-		expectedStatus duckv1alpha1.Condition
+		expectedStatus apis.Condition
 	}{{
 		name: "no-pod-scheduled",
 		taskRun: tb.TaskRun("test-taskrun-run-cancelled", "foo", tb.TaskRunSpec(
 			tb.TaskRunTaskRef(simpleTask.Name),
 			tb.TaskRunCancelled,
-		), tb.TaskRunStatus(tb.Condition(duckv1alpha1.Condition{
-			Type:   duckv1alpha1.ConditionSucceeded,
+		), tb.TaskRunStatus(tb.Condition(apis.Condition{
+			Type:   apis.ConditionSucceeded,
 			Status: corev1.ConditionUnknown,
 		}))),
-		expectedStatus: duckv1alpha1.Condition{
-			Type:    duckv1alpha1.ConditionSucceeded,
+		expectedStatus: apis.Condition{
+			Type:    apis.ConditionSucceeded,
 			Status:  corev1.ConditionFalse,
 			Reason:  "TaskRunCancelled",
 			Message: `TaskRun "test-taskrun-run-cancelled" was cancelled`,
@@ -56,16 +56,16 @@ func TestCancelTaskRun(t *testing.T) {
 		taskRun: tb.TaskRun("test-taskrun-run-cancelled", "foo", tb.TaskRunSpec(
 			tb.TaskRunTaskRef(simpleTask.Name),
 			tb.TaskRunCancelled,
-		), tb.TaskRunStatus(tb.Condition(duckv1alpha1.Condition{
-			Type:   duckv1alpha1.ConditionSucceeded,
+		), tb.TaskRunStatus(tb.Condition(apis.Condition{
+			Type:   apis.ConditionSucceeded,
 			Status: corev1.ConditionUnknown,
 		}), tb.PodName("foo-is-bar"))),
 		pod: &corev1.Pod{ObjectMeta: metav1.ObjectMeta{
 			Namespace: "foo",
 			Name:      "foo-is-bar",
 		}},
-		expectedStatus: duckv1alpha1.Condition{
-			Type:    duckv1alpha1.ConditionSucceeded,
+		expectedStatus: apis.Condition{
+			Type:    apis.ConditionSucceeded,
 			Status:  corev1.ConditionFalse,
 			Reason:  "TaskRunCancelled",
 			Message: `TaskRun "test-taskrun-run-cancelled" was cancelled`,
@@ -87,7 +87,7 @@ func TestCancelTaskRun(t *testing.T) {
 			if err != nil {
 				t.Fatal(err)
 			}
-			if d := cmp.Diff(tc.taskRun.Status.GetCondition(duckv1alpha1.ConditionSucceeded), &tc.expectedStatus, ignoreLastTransitionTime); d != "" {
+			if d := cmp.Diff(tc.taskRun.Status.GetCondition(apis.ConditionSucceeded), &tc.expectedStatus, ignoreLastTransitionTime); d != "" {
 				t.Fatalf("-want, +got: %v", d)
 			}
 		})
diff --git a/pkg/reconciler/v1alpha1/taskrun/taskrun.go b/pkg/reconciler/v1alpha1/taskrun/taskrun.go
index 3ab820c3238..1fae04a1f5a 100644
--- a/pkg/reconciler/v1alpha1/taskrun/taskrun.go
+++ b/pkg/reconciler/v1alpha1/taskrun/taskrun.go
@@ -22,7 +22,7 @@ import (
 	"reflect"
 	"time"
 
-	duckv1alpha1 "github.com/knative/pkg/apis/duck/v1alpha1"
+	"github.com/knative/pkg/apis"
 	"github.com/knative/pkg/controller"
 	"github.com/knative/pkg/tracker"
 	"github.com/tektoncd/pipeline/pkg/apis/pipeline"
@@ -212,9 +212,9 @@ func (c *Reconciler) getTaskFunc(tr *v1alpha1.TaskRun) resources.GetTask {
 func (c *Reconciler) reconcile(ctx context.Context, tr *v1alpha1.TaskRun) error {
 	// If the taskrun is cancelled, kill resources and update status
 	if tr.IsCancelled() {
-		before := tr.Status.GetCondition(duckv1alpha1.ConditionSucceeded)
+		before := tr.Status.GetCondition(apis.ConditionSucceeded)
 		err := cancelTaskRun(tr, c.KubeClientSet, c.Logger)
-		after := tr.Status.GetCondition(duckv1alpha1.ConditionSucceeded)
+		after := tr.Status.GetCondition(apis.ConditionSucceeded)
 		reconciler.EmitEvent(c.Recorder, before, after, tr)
 		return err
 	}
@@ -223,8 +223,8 @@ func (c *Reconciler) reconcile(ctx context.Context, tr *v1alpha1.TaskRun) error
 	taskMeta, taskSpec, err := resources.GetTaskData(tr, getTaskFunc)
 	if err != nil {
 		c.Logger.Errorf("Failed to determine Task spec to use for taskrun %s: %v", tr.Name, err)
-		tr.Status.SetCondition(&duckv1alpha1.Condition{
-			Type:    duckv1alpha1.ConditionSucceeded,
+		tr.Status.SetCondition(&apis.Condition{
+			Type:    apis.ConditionSucceeded,
 			Status:  corev1.ConditionFalse,
 			Reason:  reasonFailedResolution,
 			Message: err.Error(),
@@ -254,8 +254,8 @@ func (c *Reconciler) reconcile(ctx context.Context, tr *v1alpha1.TaskRun) error
 	rtr, err := resources.ResolveTaskResources(taskSpec, taskMeta.Name, tr.Spec.Inputs.Resources, tr.Spec.Outputs.Resources, c.resourceLister.PipelineResources(tr.Namespace).Get)
 	if err != nil {
 		c.Logger.Errorf("Failed to resolve references for taskrun %s: %v", tr.Name, err)
-		tr.Status.SetCondition(&duckv1alpha1.Condition{
-			Type:    duckv1alpha1.ConditionSucceeded,
+		tr.Status.SetCondition(&apis.Condition{
+			Type:    apis.ConditionSucceeded,
 			Status:  corev1.ConditionFalse,
 			Reason:  reasonFailedResolution,
 			Message: err.Error(),
@@ -265,8 +265,8 @@ func (c *Reconciler) reconcile(ctx context.Context, tr *v1alpha1.TaskRun) error
 
 	if err := ValidateResolvedTaskResources(tr.Spec.Inputs.Params, rtr); err != nil {
 		c.Logger.Errorf("Failed to validate taskrun %q: %v", tr.Name, err)
-		tr.Status.SetCondition(&duckv1alpha1.Condition{
-			Type:    duckv1alpha1.ConditionSucceeded,
+		tr.Status.SetCondition(&apis.Condition{
+			Type:    apis.ConditionSucceeded,
 			Status:  corev1.ConditionFalse,
 			Reason:  reasonFailedValidation,
 			Message: err.Error(),
@@ -294,8 +294,8 @@ func (c *Reconciler) reconcile(ctx context.Context, tr *v1alpha1.TaskRun) error
 			} else {
 				msg = fmt.Sprintf("References a TaskSpec with missing information: ")
 			}
-			tr.Status.SetCondition(&duckv1alpha1.Condition{
-				Type:    duckv1alpha1.ConditionSucceeded,
+			tr.Status.SetCondition(&apis.Condition{
+				Type:    apis.ConditionSucceeded,
 				Status:  corev1.ConditionFalse,
 				Reason:  reasonCouldntGetTask,
 				Message: fmt.Sprintf("%s %v", msg, err),
@@ -311,13 +311,13 @@ func (c *Reconciler) reconcile(ctx context.Context, tr *v1alpha1.TaskRun) error
 		return err
 	}
 
-	before := tr.Status.GetCondition(duckv1alpha1.ConditionSucceeded)
+	before := tr.Status.GetCondition(apis.ConditionSucceeded)
 
 	c.timeoutHandler.StatusLock(tr)
 	updateStatusFromPod(tr, pod)
 	c.timeoutHandler.StatusUnlock(tr)
 
-	after := tr.Status.GetCondition(duckv1alpha1.ConditionSucceeded)
+	after := tr.Status.GetCondition(apis.ConditionSucceeded)
 
 	reconciler.EmitEvent(c.Recorder, before, after, tr)
 
@@ -327,10 +327,10 @@ func (c *Reconciler) reconcile(ctx context.Context, tr *v1alpha1.TaskRun) error
 }
 
 func updateStatusFromPod(taskRun *v1alpha1.TaskRun, pod *corev1.Pod) {
-	if taskRun.Status.GetCondition(duckv1alpha1.ConditionSucceeded) == nil || taskRun.Status.GetCondition(duckv1alpha1.ConditionSucceeded).Status == corev1.ConditionUnknown {
+	if taskRun.Status.GetCondition(apis.ConditionSucceeded) == nil || taskRun.Status.GetCondition(apis.ConditionSucceeded).Status == corev1.ConditionUnknown {
 		// If the taskRunStatus doesn't exist yet, it's because we just started running
-		taskRun.Status.SetCondition(&duckv1alpha1.Condition{
-			Type:    duckv1alpha1.ConditionSucceeded,
+		taskRun.Status.SetCondition(&apis.Condition{
+			Type:    apis.ConditionSucceeded,
 			Status:  corev1.ConditionUnknown,
 			Reason:  reasonRunning,
 			Message: reasonRunning,
@@ -349,15 +349,15 @@ func updateStatusFromPod(taskRun *v1alpha1.TaskRun, pod *corev1.Pod) {
 
 	switch pod.Status.Phase {
 	case corev1.PodRunning:
-		taskRun.Status.SetCondition(&duckv1alpha1.Condition{
-			Type:   duckv1alpha1.ConditionSucceeded,
+		taskRun.Status.SetCondition(&apis.Condition{
+			Type:   apis.ConditionSucceeded,
 			Status: corev1.ConditionUnknown,
 			Reason: "Building",
 		})
 	case corev1.PodFailed:
 		msg := getFailureMessage(pod)
-		taskRun.Status.SetCondition(&duckv1alpha1.Condition{
-			Type:    duckv1alpha1.ConditionSucceeded,
+		taskRun.Status.SetCondition(&apis.Condition{
+			Type:    apis.ConditionSucceeded,
 			Status:  corev1.ConditionFalse,
 			Message: msg,
 		})
@@ -365,15 +365,15 @@ func updateStatusFromPod(taskRun *v1alpha1.TaskRun, pod *corev1.Pod) {
 		taskRun.Status.CompletionTime = &metav1.Time{Time: time.Now()}
 	case corev1.PodPending:
 		msg := getWaitingMessage(pod)
-		taskRun.Status.SetCondition(&duckv1alpha1.Condition{
-			Type:    duckv1alpha1.ConditionSucceeded,
+		taskRun.Status.SetCondition(&apis.Condition{
+			Type:    apis.ConditionSucceeded,
 			Status:  corev1.ConditionUnknown,
 			Reason:  "Pending",
 			Message: msg,
 		})
 	case corev1.PodSucceeded:
-		taskRun.Status.SetCondition(&duckv1alpha1.Condition{
-			Type:   duckv1alpha1.ConditionSucceeded,
+		taskRun.Status.SetCondition(&apis.Condition{
+			Type:   apis.ConditionSucceeded,
 			Status: corev1.ConditionTrue,
 		})
 		// update tr completed time
@@ -543,8 +543,8 @@ func (c *Reconciler) checkTimeout(tr *v1alpha1.TaskRun, ts *v1alpha1.TaskSpec, d
 			}
 
 			timeoutMsg := fmt.Sprintf("TaskRun %q failed to finish within %q", tr.Name, timeout.String())
-			tr.Status.SetCondition(&duckv1alpha1.Condition{
-				Type:    duckv1alpha1.ConditionSucceeded,
+			tr.Status.SetCondition(&apis.Condition{
+				Type:    apis.ConditionSucceeded,
 				Status:  corev1.ConditionFalse,
 				Reason:  reasonTimedOut,
 				Message: timeoutMsg,
diff --git a/pkg/reconciler/v1alpha1/taskrun/taskrun_test.go b/pkg/reconciler/v1alpha1/taskrun/taskrun_test.go
index b45584be9f3..fdb34789243 100644
--- a/pkg/reconciler/v1alpha1/taskrun/taskrun_test.go
+++ b/pkg/reconciler/v1alpha1/taskrun/taskrun_test.go
@@ -23,7 +23,7 @@ import (
 	"github.com/google/go-cmp/cmp"
 	"github.com/google/go-cmp/cmp/cmpopts"
 	"github.com/knative/pkg/apis"
-	duckv1alpha1 "github.com/knative/pkg/apis/duck/v1alpha1"
+	duckv1beta1 "github.com/knative/pkg/apis/duck/v1beta1"
 	"github.com/knative/pkg/configmap"
 	"github.com/tektoncd/pipeline/pkg/apis/pipeline"
 	"github.com/tektoncd/pipeline/pkg/apis/pipeline/v1alpha1"
@@ -54,7 +54,7 @@ const (
 
 var (
 	entrypointCache          *entrypoint.Cache
-	ignoreLastTransitionTime = cmpopts.IgnoreTypes(duckv1alpha1.Condition{}.LastTransitionTime.Inner.Time)
+	ignoreLastTransitionTime = cmpopts.IgnoreTypes(apis.Condition{}.LastTransitionTime.Inner.Time)
 	ignoreVolatileTime       = cmp.Comparer(func(_, _ apis.VolatileTime) bool { return true })
 	// Pods are created with a random 3-byte (6 hex character) suffix that we want to ignore in our diffs.
 	ignoreRandomPodNameSuffix = cmp.FilterPath(func(path cmp.Path) bool {
@@ -655,7 +655,7 @@ func TestReconcile(t *testing.T) {
 			if err != nil {
 				t.Fatalf("getting updated taskrun: %v", err)
 			}
-			condition := tr.Status.GetCondition(duckv1alpha1.ConditionSucceeded)
+			condition := tr.Status.GetCondition(apis.ConditionSucceeded)
 			if condition == nil || condition.Status != corev1.ConditionUnknown {
 				t.Errorf("Expected invalid TaskRun to have in progress status, but had %v", condition)
 			}
@@ -732,7 +732,7 @@ func TestReconcileInvalidTaskRuns(t *testing.T) {
 				t.Errorf("expected no actions created by the reconciler, got %v", clients.Kube.Actions())
 			}
 			// Since the TaskRun is invalid, the status should say it has failed
-			condition := tc.taskRun.Status.GetCondition(duckv1alpha1.ConditionSucceeded)
+			condition := tc.taskRun.Status.GetCondition(apis.ConditionSucceeded)
 			if condition == nil || condition.Status != corev1.ConditionFalse {
 				t.Errorf("Expected invalid TaskRun to have failed status, but had %v", condition)
 			}
@@ -810,8 +810,8 @@ func TestReconcilePodUpdateStatus(t *testing.T) {
 	if err != nil {
 		t.Fatalf("Expected TaskRun %s to exist but instead got error when getting it: %v", taskRun.Name, err)
 	}
-	if d := cmp.Diff(newTr.Status.GetCondition(duckv1alpha1.ConditionSucceeded), &duckv1alpha1.Condition{
-		Type:    duckv1alpha1.ConditionSucceeded,
+	if d := cmp.Diff(newTr.Status.GetCondition(apis.ConditionSucceeded), &apis.Condition{
+		Type:    apis.ConditionSucceeded,
 		Status:  corev1.ConditionUnknown,
 		Message: "Running",
 		Reason:  "Running",
@@ -834,8 +834,8 @@ func TestReconcilePodUpdateStatus(t *testing.T) {
 	if err != nil {
 		t.Fatalf("Unexpected error fetching taskrun: %v", err)
 	}
-	if d := cmp.Diff(newTr.Status.GetCondition(duckv1alpha1.ConditionSucceeded), &duckv1alpha1.Condition{
-		Type:   duckv1alpha1.ConditionSucceeded,
+	if d := cmp.Diff(newTr.Status.GetCondition(apis.ConditionSucceeded), &apis.Condition{
+		Type:   apis.ConditionSucceeded,
 		Status: corev1.ConditionTrue,
 	}, ignoreLastTransitionTime); d != "" {
 		t.Errorf("Taskrun Status diff -got, +want: %v", d)
@@ -871,8 +871,8 @@ func TestCreateRedirectedTaskSpec(t *testing.T) {
 }
 
 func TestReconcileOnCompletedTaskRun(t *testing.T) {
-	taskSt := &duckv1alpha1.Condition{
-		Type:    duckv1alpha1.ConditionSucceeded,
+	taskSt := &apis.Condition{
+		Type:    apis.ConditionSucceeded,
 		Status:  corev1.ConditionTrue,
 		Reason:  "Build succeeded",
 		Message: "Build succeeded",
@@ -898,7 +898,7 @@ func TestReconcileOnCompletedTaskRun(t *testing.T) {
 	if err != nil {
 		t.Fatalf("Expected completed TaskRun %s to exist but instead got error when getting it: %v", taskRun.Name, err)
 	}
-	if d := cmp.Diff(newTr.Status.GetCondition(duckv1alpha1.ConditionSucceeded), taskSt, ignoreLastTransitionTime); d != "" {
+	if d := cmp.Diff(newTr.Status.GetCondition(apis.ConditionSucceeded), taskSt, ignoreLastTransitionTime); d != "" {
 		t.Fatalf("-want, +got: %v", d)
 	}
 }
@@ -907,8 +907,8 @@ func TestReconcileOnCancelledTaskRun(t *testing.T) {
 	taskRun := tb.TaskRun("test-taskrun-run-cancelled", "foo", tb.TaskRunSpec(
 		tb.TaskRunTaskRef(simpleTask.Name),
 		tb.TaskRunCancelled,
-	), tb.TaskRunStatus(tb.Condition(duckv1alpha1.Condition{
-		Type:   duckv1alpha1.ConditionSucceeded,
+	), tb.TaskRunStatus(tb.Condition(apis.Condition{
+		Type:   apis.ConditionSucceeded,
 		Status: corev1.ConditionUnknown,
 	})))
 	d := test.Data{
@@ -928,13 +928,13 @@ func TestReconcileOnCancelledTaskRun(t *testing.T) {
 		t.Fatalf("Expected completed TaskRun %s to exist but instead got error when getting it: %v", taskRun.Name, err)
 	}
 
-	expectedStatus := &duckv1alpha1.Condition{
-		Type:    duckv1alpha1.ConditionSucceeded,
+	expectedStatus := &apis.Condition{
+		Type:    apis.ConditionSucceeded,
 		Status:  corev1.ConditionFalse,
 		Reason:  "TaskRunCancelled",
 		Message: `TaskRun "test-taskrun-run-cancelled" was cancelled`,
 	}
-	if d := cmp.Diff(newTr.Status.GetCondition(duckv1alpha1.ConditionSucceeded), expectedStatus, ignoreLastTransitionTime); d != "" {
+	if d := cmp.Diff(newTr.Status.GetCondition(apis.ConditionSucceeded), expectedStatus, ignoreLastTransitionTime); d != "" {
 		t.Fatalf("-want, +got: %v", d)
 	}
 }
@@ -945,8 +945,8 @@ func TestReconcileOnTimedOutTaskRun(t *testing.T) {
 			tb.TaskRunTaskRef(simpleTask.Name),
 			tb.TaskRunTimeout(10*time.Second),
 		),
-		tb.TaskRunStatus(tb.Condition(duckv1alpha1.Condition{
-			Type:   duckv1alpha1.ConditionSucceeded,
+		tb.TaskRunStatus(tb.Condition(apis.Condition{
+			Type:   apis.ConditionSucceeded,
 			Status: corev1.ConditionUnknown}),
 			tb.TaskRunStartTime(time.Now().Add(-15*time.Second))))
 
@@ -967,30 +967,30 @@ func TestReconcileOnTimedOutTaskRun(t *testing.T) {
 		t.Fatalf("Expected completed TaskRun %s to exist but instead got error when getting it: %v", taskRun.Name, err)
 	}
 
-	expectedStatus := &duckv1alpha1.Condition{
-		Type:    duckv1alpha1.ConditionSucceeded,
+	expectedStatus := &apis.Condition{
+		Type:    apis.ConditionSucceeded,
 		Status:  corev1.ConditionFalse,
 		Reason:  "TaskRunTimeout",
 		Message: `TaskRun "test-taskrun-timeout" failed to finish within "10s"`,
 	}
-	if d := cmp.Diff(newTr.Status.GetCondition(duckv1alpha1.ConditionSucceeded), expectedStatus, ignoreLastTransitionTime); d != "" {
+	if d := cmp.Diff(newTr.Status.GetCondition(apis.ConditionSucceeded), expectedStatus, ignoreLastTransitionTime); d != "" {
 		t.Fatalf("-want, +got: %v", d)
 	}
 }
 
 func TestUpdateStatusFromPod(t *testing.T) {
-	conditionRunning := duckv1alpha1.Condition{
-		Type:    duckv1alpha1.ConditionSucceeded,
+	conditionRunning := apis.Condition{
+		Type:    apis.ConditionSucceeded,
 		Status:  corev1.ConditionUnknown,
 		Reason:  reasonRunning,
 		Message: reasonRunning,
 	}
-	conditionTrue := duckv1alpha1.Condition{
-		Type:   duckv1alpha1.ConditionSucceeded,
+	conditionTrue := apis.Condition{
+		Type:   apis.ConditionSucceeded,
 		Status: corev1.ConditionTrue,
 	}
-	conditionBuilding := duckv1alpha1.Condition{
-		Type:   duckv1alpha1.ConditionSucceeded,
+	conditionBuilding := apis.Condition{
+		Type:   apis.ConditionSucceeded,
 		Status: corev1.ConditionUnknown,
 		Reason: "Building",
 	}
@@ -1010,8 +1010,10 @@ func TestUpdateStatusFromPod(t *testing.T) {
 		podStatus: corev1.PodStatus{},
 
 		want: v1alpha1.TaskRunStatus{
-			Conditions: []duckv1alpha1.Condition{conditionRunning},
-			Steps:      []v1alpha1.StepState{},
+			Status: duckv1beta1.Status{
+				Conditions: []apis.Condition{conditionRunning},
+			},
+			Steps: []v1alpha1.StepState{},
 		},
 	}, {
 		desc: "ignore-creds-init",
@@ -1029,7 +1031,9 @@ func TestUpdateStatusFromPod(t *testing.T) {
 			}},
 		},
 		want: v1alpha1.TaskRunStatus{
-			Conditions: []duckv1alpha1.Condition{conditionRunning},
+			Status: duckv1beta1.Status{
+				Conditions: []apis.Condition{conditionRunning},
+			},
 			Steps: []v1alpha1.StepState{{
 				corev1.ContainerState{
 					Terminated: &corev1.ContainerStateTerminated{
@@ -1055,7 +1059,9 @@ func TestUpdateStatusFromPod(t *testing.T) {
 			}},
 		},
 		want: v1alpha1.TaskRunStatus{
-			Conditions: []duckv1alpha1.Condition{conditionRunning},
+			Status: duckv1beta1.Status{
+				Conditions: []apis.Condition{conditionRunning},
+			},
 			Steps: []v1alpha1.StepState{{
 				corev1.ContainerState{
 					Terminated: &corev1.ContainerStateTerminated{
@@ -1067,8 +1073,10 @@ func TestUpdateStatusFromPod(t *testing.T) {
 		desc:      "success",
 		podStatus: corev1.PodStatus{Phase: corev1.PodSucceeded},
 		want: v1alpha1.TaskRunStatus{
-			Conditions: []duckv1alpha1.Condition{conditionTrue},
-			Steps:      []v1alpha1.StepState{},
+			Status: duckv1beta1.Status{
+				Conditions: []apis.Condition{conditionTrue},
+			},
+			Steps: []v1alpha1.StepState{},
 			// We don't actually care about the time, just that it's not nil
 			CompletionTime: &metav1.Time{Time: time.Now()},
 		},
@@ -1076,8 +1084,10 @@ func TestUpdateStatusFromPod(t *testing.T) {
 		desc:      "running",
 		podStatus: corev1.PodStatus{Phase: corev1.PodRunning},
 		want: v1alpha1.TaskRunStatus{
-			Conditions: []duckv1alpha1.Condition{conditionBuilding},
-			Steps:      []v1alpha1.StepState{},
+			Status: duckv1beta1.Status{
+				Conditions: []apis.Condition{conditionBuilding},
+			},
+			Steps: []v1alpha1.StepState{},
 		},
 	}, {
 		desc: "failure-terminated",
@@ -1097,11 +1107,13 @@ func TestUpdateStatusFromPod(t *testing.T) {
 			}},
 		},
 		want: v1alpha1.TaskRunStatus{
-			Conditions: []duckv1alpha1.Condition{{
-				Type:    duckv1alpha1.ConditionSucceeded,
-				Status:  corev1.ConditionFalse,
-				Message: `build step "status-name" exited with code 123 (image: "image-id"); for logs run: kubectl -n foo logs pod -c status-name`,
-			}},
+			Status: duckv1beta1.Status{
+				Conditions: []apis.Condition{{
+					Type:    apis.ConditionSucceeded,
+					Status:  corev1.ConditionFalse,
+					Message: `build step "status-name" exited with code 123 (image: "image-id"); for logs run: kubectl -n foo logs pod -c status-name`,
+				}},
+			},
 			Steps: []v1alpha1.StepState{{
 				corev1.ContainerState{
 					Terminated: &corev1.ContainerStateTerminated{
@@ -1118,11 +1130,13 @@ func TestUpdateStatusFromPod(t *testing.T) {
 			Message: "boom",
 		},
 		want: v1alpha1.TaskRunStatus{
-			Conditions: []duckv1alpha1.Condition{{
-				Type:    duckv1alpha1.ConditionSucceeded,
-				Status:  corev1.ConditionFalse,
-				Message: "boom",
-			}},
+			Status: duckv1beta1.Status{
+				Conditions: []apis.Condition{{
+					Type:    apis.ConditionSucceeded,
+					Status:  corev1.ConditionFalse,
+					Message: "boom",
+				}},
+			},
 			Steps: []v1alpha1.StepState{},
 			// We don't actually care about the time, just that it's not nil
 			CompletionTime: &metav1.Time{Time: time.Now()},
@@ -1131,11 +1145,13 @@ func TestUpdateStatusFromPod(t *testing.T) {
 		desc:      "failure-unspecified",
 		podStatus: corev1.PodStatus{Phase: corev1.PodFailed},
 		want: v1alpha1.TaskRunStatus{
-			Conditions: []duckv1alpha1.Condition{{
-				Type:    duckv1alpha1.ConditionSucceeded,
-				Status:  corev1.ConditionFalse,
-				Message: "build failed for unspecified reasons.",
-			}},
+			Status: duckv1beta1.Status{
+				Conditions: []apis.Condition{{
+					Type:    apis.ConditionSucceeded,
+					Status:  corev1.ConditionFalse,
+					Message: "build failed for unspecified reasons.",
+				}},
+			},
 			Steps: []v1alpha1.StepState{},
 			// We don't actually care about the time, just that it's not nil
 			CompletionTime: &metav1.Time{Time: time.Now()},
@@ -1157,12 +1173,14 @@ func TestUpdateStatusFromPod(t *testing.T) {
 			}},
 		},
 		want: v1alpha1.TaskRunStatus{
-			Conditions: []duckv1alpha1.Condition{{
-				Type:    duckv1alpha1.ConditionSucceeded,
-				Status:  corev1.ConditionUnknown,
-				Reason:  "Pending",
-				Message: `build step "status-name" is pending with reason "i'm pending"`,
-			}},
+			Status: duckv1beta1.Status{
+				Conditions: []apis.Condition{{
+					Type:    apis.ConditionSucceeded,
+					Status:  corev1.ConditionUnknown,
+					Reason:  "Pending",
+					Message: `build step "status-name" is pending with reason "i'm pending"`,
+				}},
+			},
 			Steps: []v1alpha1.StepState{{
 				corev1.ContainerState{
 					Waiting: &corev1.ContainerStateWaiting{
@@ -1182,12 +1200,14 @@ func TestUpdateStatusFromPod(t *testing.T) {
 			}},
 		},
 		want: v1alpha1.TaskRunStatus{
-			Conditions: []duckv1alpha1.Condition{{
-				Type:    duckv1alpha1.ConditionSucceeded,
-				Status:  corev1.ConditionUnknown,
-				Reason:  "Pending",
-				Message: `pod status "the type":"Unknown"; message: "the message"`,
-			}},
+			Status: duckv1beta1.Status{
+				Conditions: []apis.Condition{{
+					Type:    apis.ConditionSucceeded,
+					Status:  corev1.ConditionUnknown,
+					Reason:  "Pending",
+					Message: `pod status "the type":"Unknown"; message: "the message"`,
+				}},
+			},
 			Steps: []v1alpha1.StepState{},
 		},
 	}, {
@@ -1197,24 +1217,28 @@ func TestUpdateStatusFromPod(t *testing.T) {
 			Message: "pod status message",
 		},
 		want: v1alpha1.TaskRunStatus{
-			Conditions: []duckv1alpha1.Condition{{
-				Type:    duckv1alpha1.ConditionSucceeded,
-				Status:  corev1.ConditionUnknown,
-				Reason:  "Pending",
-				Message: "pod status message",
-			}},
+			Status: duckv1beta1.Status{
+				Conditions: []apis.Condition{{
+					Type:    apis.ConditionSucceeded,
+					Status:  corev1.ConditionUnknown,
+					Reason:  "Pending",
+					Message: "pod status message",
+				}},
+			},
 			Steps: []v1alpha1.StepState{},
 		},
 	}, {
 		desc:      "pending-no-message",
 		podStatus: corev1.PodStatus{Phase: corev1.PodPending},
 		want: v1alpha1.TaskRunStatus{
-			Conditions: []duckv1alpha1.Condition{{
-				Type:    duckv1alpha1.ConditionSucceeded,
-				Status:  corev1.ConditionUnknown,
-				Reason:  "Pending",
-				Message: "Pending",
-			}},
+			Status: duckv1beta1.Status{
+				Conditions: []apis.Condition{{
+					Type:    apis.ConditionSucceeded,
+					Status:  corev1.ConditionUnknown,
+					Reason:  "Pending",
+					Message: "Pending",
+				}},
+			},
 			Steps: []v1alpha1.StepState{},
 		},
 	}} {
diff --git a/test/builder/pipeline.go b/test/builder/pipeline.go
index 620f37c3cd8..1a8df2a1b1e 100644
--- a/test/builder/pipeline.go
+++ b/test/builder/pipeline.go
@@ -16,7 +16,7 @@ package builder
 import (
 	"time"
 
-	duckv1alpha1 "github.com/knative/pkg/apis/duck/v1alpha1"
+	"github.com/knative/pkg/apis"
 	"github.com/tektoncd/pipeline/pkg/apis/pipeline/v1alpha1"
 	corev1 "k8s.io/api/core/v1"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
@@ -335,7 +335,7 @@ func PipelineRunStatus(ops ...PipelineRunStatusOp) PipelineRunOp {
 }
 
 // PipelineRunStatusCondition adds a Condition to the TaskRunStatus.
-func PipelineRunStatusCondition(condition duckv1alpha1.Condition) PipelineRunStatusOp {
+func PipelineRunStatusCondition(condition apis.Condition) PipelineRunStatusOp {
 	return func(s *v1alpha1.PipelineRunStatus) {
 		s.Conditions = append(s.Conditions, condition)
 	}
diff --git a/test/builder/pipeline_test.go b/test/builder/pipeline_test.go
index 5ffcc68ed8c..771783058cb 100644
--- a/test/builder/pipeline_test.go
+++ b/test/builder/pipeline_test.go
@@ -18,7 +18,8 @@ import (
 	"time"
 
 	"github.com/google/go-cmp/cmp"
-	duckv1alpha1 "github.com/knative/pkg/apis/duck/v1alpha1"
+	"github.com/knative/pkg/apis"
+	duckv1beta1 "github.com/knative/pkg/apis/duck/v1beta1"
 	"github.com/tektoncd/pipeline/pkg/apis/pipeline/v1alpha1"
 	tb "github.com/tektoncd/pipeline/test/builder"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
@@ -93,8 +94,8 @@ func TestPipelineRun(t *testing.T) {
 		tb.PipelineRunParam("first-param", "first-value"),
 		tb.PipelineRunTimeout(&metav1.Duration{Duration: 1 * time.Hour}),
 		tb.PipelineRunResourceBinding("some-resource", tb.PipelineResourceBindingRef("my-special-resource")),
-	), tb.PipelineRunStatus(tb.PipelineRunStatusCondition(duckv1alpha1.Condition{
-		Type: duckv1alpha1.ConditionSucceeded,
+	), tb.PipelineRunStatus(tb.PipelineRunStatusCondition(apis.Condition{
+		Type: apis.ConditionSucceeded,
 	}), tb.PipelineRunStartTime(startTime),
 	), tb.PipelineRunLabel("label-key", "label-value"))
 	expectedPipelineRun := &v1alpha1.PipelineRun{
@@ -122,8 +123,10 @@ func TestPipelineRun(t *testing.T) {
 			}},
 		},
 		Status: v1alpha1.PipelineRunStatus{
-			Conditions: []duckv1alpha1.Condition{{Type: duckv1alpha1.ConditionSucceeded}},
-			StartTime:  &metav1.Time{Time: startTime},
+			Status: duckv1beta1.Status{
+				Conditions: []apis.Condition{{Type: apis.ConditionSucceeded}},
+			},
+			StartTime: &metav1.Time{Time: startTime},
 		},
 	}
 	if d := cmp.Diff(expectedPipelineRun, pipelineRun); d != "" {
diff --git a/test/builder/task.go b/test/builder/task.go
index b9fddac56d3..c377dfebbbc 100644
--- a/test/builder/task.go
+++ b/test/builder/task.go
@@ -16,7 +16,7 @@ package builder
 import (
 	"time"
 
-	duckv1alpha1 "github.com/knative/pkg/apis/duck/v1alpha1"
+	"github.com/knative/pkg/apis"
 	"github.com/tektoncd/pipeline/pkg/apis/pipeline/v1alpha1"
 	"github.com/tektoncd/pipeline/pkg/reconciler/v1alpha1/taskrun/resources"
 	corev1 "k8s.io/api/core/v1"
@@ -285,7 +285,7 @@ func PodName(name string) TaskRunStatusOp {
 }
 
 // Condition adds a Condition to the TaskRunStatus.
-func Condition(condition duckv1alpha1.Condition) TaskRunStatusOp {
+func Condition(condition apis.Condition) TaskRunStatusOp {
 	return func(s *v1alpha1.TaskRunStatus) {
 		s.Conditions = append(s.Conditions, condition)
 	}
diff --git a/test/builder/task_test.go b/test/builder/task_test.go
index fe9a955e309..f18d4d53af5 100644
--- a/test/builder/task_test.go
+++ b/test/builder/task_test.go
@@ -18,7 +18,8 @@ import (
 	"time"
 
 	"github.com/google/go-cmp/cmp"
-	duckv1alpha1 "github.com/knative/pkg/apis/duck/v1alpha1"
+	"github.com/knative/pkg/apis"
+	duckv1beta1 "github.com/knative/pkg/apis/duck/v1beta1"
 	"github.com/tektoncd/pipeline/pkg/apis/pipeline/v1alpha1"
 	"github.com/tektoncd/pipeline/pkg/reconciler/v1alpha1/taskrun/resources"
 	tb "github.com/tektoncd/pipeline/test/builder"
@@ -140,7 +141,7 @@ func TestTaskRunWitTaskRef(t *testing.T) {
 		),
 		tb.TaskRunStatus(
 			tb.PodName("my-pod-name"),
-			tb.Condition(duckv1alpha1.Condition{Type: duckv1alpha1.ConditionSucceeded}),
+			tb.Condition(apis.Condition{Type: apis.ConditionSucceeded}),
 			tb.StepState(tb.StateTerminated(127)),
 		),
 	)
@@ -188,8 +189,10 @@ func TestTaskRunWitTaskRef(t *testing.T) {
 			},
 		},
 		Status: v1alpha1.TaskRunStatus{
-			PodName:    "my-pod-name",
-			Conditions: []duckv1alpha1.Condition{{Type: duckv1alpha1.ConditionSucceeded}},
+			PodName: "my-pod-name",
+			Status: duckv1beta1.Status{
+				Conditions: []apis.Condition{{Type: apis.ConditionSucceeded}},
+			},
 			Steps: []v1alpha1.StepState{{ContainerState: corev1.ContainerState{
 				Terminated: &corev1.ContainerStateTerminated{ExitCode: 127},
 			}}},
diff --git a/test/cancel_test.go b/test/cancel_test.go
index 27a4f7c3b9b..714a852b530 100644
--- a/test/cancel_test.go
+++ b/test/cancel_test.go
@@ -20,13 +20,12 @@ import (
 	"sync"
 	"testing"
 
-	duckv1alpha1 "github.com/knative/pkg/apis/duck/v1alpha1"
+	"github.com/knative/pkg/apis"
 	knativetest "github.com/knative/pkg/test"
-	corev1 "k8s.io/api/core/v1"
-	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
-
 	"github.com/tektoncd/pipeline/pkg/apis/pipeline/v1alpha1"
 	tb "github.com/tektoncd/pipeline/test/builder"
+	corev1 "k8s.io/api/core/v1"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 )
 
 // TestTaskRunPipelineRunCancel is an integration test that will
@@ -64,7 +63,7 @@ func TestTaskRunPipelineRunCancel(t *testing.T) {
 
 	t.Logf("Waiting for Pipelinerun %s in namespace %s to be started", "pear", namespace)
 	if err := WaitForPipelineRunState(c, "pear", pipelineRunTimeout, func(pr *v1alpha1.PipelineRun) (bool, error) {
-		c := pr.Status.GetCondition(duckv1alpha1.ConditionSucceeded)
+		c := pr.Status.GetCondition(apis.ConditionSucceeded)
 		if c != nil {
 			if c.Status == corev1.ConditionTrue || c.Status == corev1.ConditionFalse {
 				return true, fmt.Errorf("pipelineRun %s already finished", "pear")
@@ -89,7 +88,7 @@ func TestTaskRunPipelineRunCancel(t *testing.T) {
 		go func(name string) {
 			defer wg.Done()
 			err := WaitForTaskRunState(c, name, func(tr *v1alpha1.TaskRun) (bool, error) {
-				if c := tr.Status.GetCondition(duckv1alpha1.ConditionSucceeded); c != nil {
+				if c := tr.Status.GetCondition(apis.ConditionSucceeded); c != nil {
 					if c.IsTrue() || c.IsFalse() {
 						return true, fmt.Errorf("taskRun %s already finished!", name)
 					} else if c.IsUnknown() && (c.Reason == "Running" || c.Reason == "Pending") {
@@ -117,7 +116,7 @@ func TestTaskRunPipelineRunCancel(t *testing.T) {
 
 	t.Logf("Waiting for PipelineRun %s in namespace %s to be cancelled", "pear", namespace)
 	if err := WaitForPipelineRunState(c, "pear", pipelineRunTimeout, func(pr *v1alpha1.PipelineRun) (bool, error) {
-		if c := pr.Status.GetCondition(duckv1alpha1.ConditionSucceeded); c != nil {
+		if c := pr.Status.GetCondition(apis.ConditionSucceeded); c != nil {
 			if c.IsFalse() {
 				if c.Reason == "PipelineRunCancelled" {
 					return true, nil
@@ -138,7 +137,7 @@ func TestTaskRunPipelineRunCancel(t *testing.T) {
 		go func(name string) {
 			defer wg.Done()
 			err := WaitForTaskRunState(c, name, func(tr *v1alpha1.TaskRun) (bool, error) {
-				if c := tr.Status.GetCondition(duckv1alpha1.ConditionSucceeded); c != nil {
+				if c := tr.Status.GetCondition(apis.ConditionSucceeded); c != nil {
 					if c.IsFalse() {
 						if c.Reason == "TaskRunCancelled" {
 							return true, nil
diff --git a/test/pipelinerun_test.go b/test/pipelinerun_test.go
index 08fc5c3281a..eee521fcc51 100644
--- a/test/pipelinerun_test.go
+++ b/test/pipelinerun_test.go
@@ -25,14 +25,13 @@ import (
 	"testing"
 	"time"
 
-	duckv1alpha1 "github.com/knative/pkg/apis/duck/v1alpha1"
+	"github.com/knative/pkg/apis"
 	knativetest "github.com/knative/pkg/test"
 	"github.com/tektoncd/pipeline/pkg/apis/pipeline"
+	"github.com/tektoncd/pipeline/pkg/apis/pipeline/v1alpha1"
 	tb "github.com/tektoncd/pipeline/test/builder"
 	corev1 "k8s.io/api/core/v1"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
-
-	"github.com/tektoncd/pipeline/pkg/apis/pipeline/v1alpha1"
 )
 
 var (
@@ -154,7 +153,7 @@ func TestPipelineRun(t *testing.T) {
 				if err != nil {
 					t.Fatalf("Couldn't get expected TaskRun %s: %s", taskRunName, err)
 				}
-				if !r.Status.GetCondition(duckv1alpha1.ConditionSucceeded).IsTrue() {
+				if !r.Status.GetCondition(apis.ConditionSucceeded).IsTrue() {
 					t.Fatalf("Expected TaskRun %s to have succeeded but Status is %v", taskRunName, r.Status)
 				}
 
diff --git a/test/timeout_test.go b/test/timeout_test.go
index 70785f6b4d6..52e5fffe74c 100644
--- a/test/timeout_test.go
+++ b/test/timeout_test.go
@@ -21,7 +21,7 @@ import (
 	"testing"
 	"time"
 
-	duckv1alpha1 "github.com/knative/pkg/apis/duck/v1alpha1"
+	"github.com/knative/pkg/apis"
 	knativetest "github.com/knative/pkg/test"
 	"github.com/tektoncd/pipeline/pkg/apis/pipeline/v1alpha1"
 	"github.com/tektoncd/pipeline/pkg/reconciler/v1alpha1/pipelinerun/resources"
@@ -62,7 +62,7 @@ func TestPipelineRunTimeout(t *testing.T) {
 
 	t.Logf("Waiting for Pipelinerun %s in namespace %s to be started", pipelineRun.Name, namespace)
 	if err := WaitForPipelineRunState(c, pipelineRun.Name, timeout, func(pr *v1alpha1.PipelineRun) (bool, error) {
-		c := pr.Status.GetCondition(duckv1alpha1.ConditionSucceeded)
+		c := pr.Status.GetCondition(apis.ConditionSucceeded)
 		if c != nil {
 			if c.Status == corev1.ConditionTrue || c.Status == corev1.ConditionFalse {
 				return true, fmt.Errorf("pipelineRun %s already finished!", pipelineRun.Name)
@@ -87,7 +87,7 @@ func TestPipelineRunTimeout(t *testing.T) {
 	for _, taskrunItem := range taskrunList.Items {
 		go func(name string) {
 			err := WaitForTaskRunState(c, name, func(tr *v1alpha1.TaskRun) (bool, error) {
-				c := tr.Status.GetCondition(duckv1alpha1.ConditionSucceeded)
+				c := tr.Status.GetCondition(apis.ConditionSucceeded)
 				if c != nil {
 					if c.Status == corev1.ConditionTrue || c.Status == corev1.ConditionFalse {
 						return true, fmt.Errorf("taskRun %s already finished!", name)
@@ -113,7 +113,7 @@ func TestPipelineRunTimeout(t *testing.T) {
 
 	t.Logf("Waiting for PipelineRun %s in namespace %s to be timed out", pipelineRun.Name, namespace)
 	if err := WaitForPipelineRunState(c, pipelineRun.Name, timeout, func(pr *v1alpha1.PipelineRun) (bool, error) {
-		c := pr.Status.GetCondition(duckv1alpha1.ConditionSucceeded)
+		c := pr.Status.GetCondition(apis.ConditionSucceeded)
 		if c != nil {
 			if c.Status == corev1.ConditionFalse {
 				if c.Reason == resources.ReasonTimedOut {
@@ -136,7 +136,7 @@ func TestPipelineRunTimeout(t *testing.T) {
 		go func(name string) {
 			defer wg.Done()
 			err := WaitForTaskRunState(c, name, func(tr *v1alpha1.TaskRun) (bool, error) {
-				cond := tr.Status.GetCondition(duckv1alpha1.ConditionSucceeded)
+				cond := tr.Status.GetCondition(apis.ConditionSucceeded)
 				if cond != nil {
 					if cond.Status == corev1.ConditionFalse {
 						if cond.Reason == "TaskRunTimeout" {
@@ -201,7 +201,7 @@ func TestTaskRunTimeout(t *testing.T) {
 
 	t.Logf("Waiting for TaskRun %s in namespace %s to complete", "run-giraffe", namespace)
 	if err := WaitForTaskRunState(c, "run-giraffe", func(tr *v1alpha1.TaskRun) (bool, error) {
-		cond := tr.Status.GetCondition(duckv1alpha1.ConditionSucceeded)
+		cond := tr.Status.GetCondition(apis.ConditionSucceeded)
 		if cond != nil {
 			if cond.Status == corev1.ConditionFalse {
 				if cond.Reason == "TaskRunTimeout" {
diff --git a/test/wait.go b/test/wait.go
index b9a009f1318..db846360276 100644
--- a/test/wait.go
+++ b/test/wait.go
@@ -48,7 +48,7 @@ import (
 	"fmt"
 	"time"
 
-	duckv1alpha1 "github.com/knative/pkg/apis/duck/v1alpha1"
+	"github.com/knative/pkg/apis"
 	"github.com/tektoncd/pipeline/pkg/apis/pipeline/v1alpha1"
 	"go.opencensus.io/trace"
 	corev1 "k8s.io/api/core/v1"
@@ -143,7 +143,7 @@ func WaitForServiceExternalIPState(c *clients, namespace, name string, inState f
 // has successfully completed.
 func TaskRunSucceed(name string) TaskRunStateFn {
 	return func(tr *v1alpha1.TaskRun) (bool, error) {
-		c := tr.Status.GetCondition(duckv1alpha1.ConditionSucceeded)
+		c := tr.Status.GetCondition(apis.ConditionSucceeded)
 		if c != nil {
 			if c.Status == corev1.ConditionTrue {
 				return true, nil
@@ -159,7 +159,7 @@ func TaskRunSucceed(name string) TaskRunStateFn {
 // has failed.
 func TaskRunFailed(name string) TaskRunStateFn {
 	return func(tr *v1alpha1.TaskRun) (bool, error) {
-		c := tr.Status.GetCondition(duckv1alpha1.ConditionSucceeded)
+		c := tr.Status.GetCondition(apis.ConditionSucceeded)
 		if c != nil {
 			if c.Status == corev1.ConditionTrue {
 				return true, fmt.Errorf("task run %s succeeded!", name)
@@ -175,7 +175,7 @@ func TaskRunFailed(name string) TaskRunStateFn {
 // has successfully completed.
 func PipelineRunSucceed(name string) PipelineRunStateFn {
 	return func(pr *v1alpha1.PipelineRun) (bool, error) {
-		c := pr.Status.GetCondition(duckv1alpha1.ConditionSucceeded)
+		c := pr.Status.GetCondition(apis.ConditionSucceeded)
 		if c != nil {
 			if c.Status == corev1.ConditionTrue {
 				return true, nil
@@ -191,7 +191,7 @@ func PipelineRunSucceed(name string) PipelineRunStateFn {
 // has failed.
 func PipelineRunFailed(name string) PipelineRunStateFn {
 	return func(tr *v1alpha1.PipelineRun) (bool, error) {
-		c := tr.Status.GetCondition(duckv1alpha1.ConditionSucceeded)
+		c := tr.Status.GetCondition(apis.ConditionSucceeded)
 		if c != nil {
 			if c.Status == corev1.ConditionTrue {
 				return true, fmt.Errorf("task run %s succeeded!", name)
diff --git a/test/wait_test.go b/test/wait_test.go
index a7fa9359718..56069195cec 100644
--- a/test/wait_test.go
+++ b/test/wait_test.go
@@ -20,7 +20,7 @@ import (
 	"testing"
 	"time"
 
-	duckv1alpha1 "github.com/knative/pkg/apis/duck/v1alpha1"
+	"github.com/knative/pkg/apis"
 	"github.com/tektoncd/pipeline/pkg/apis/pipeline/v1alpha1"
 	tb "github.com/tektoncd/pipeline/test/builder"
 	corev1 "k8s.io/api/core/v1"
@@ -31,8 +31,8 @@ const (
 )
 
 var (
-	success = duckv1alpha1.Condition{Type: duckv1alpha1.ConditionSucceeded, Status: corev1.ConditionTrue}
-	failure = duckv1alpha1.Condition{Type: duckv1alpha1.ConditionSucceeded, Status: corev1.ConditionFalse}
+	success = apis.Condition{Type: apis.ConditionSucceeded, Status: corev1.ConditionTrue}
+	failure = apis.Condition{Type: apis.ConditionSucceeded, Status: corev1.ConditionFalse}
 )
 
 func TestWaitForTaskRunStateSucceed(t *testing.T) {