ci+test: 升级 actions v5/v6 消除 Node 20 warning + contracts/runtime 测试

- actions/checkout v4→v5, setup-go v5→v6, setup-node v4→v5
- pkg/contracts: CrossCheck 全路径测试（matchPath/methodExists/空契约）
- pkg/runtime: Backend 常量验证 + Runtime 接口编译期检查
- contracts 100% 覆盖率, runtime 接口契约测试

Author: zengfr

.github/workflows/ci.yml

@@ -10,8 +10,8 @@ jobs:
   go:
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v4
-      - uses: actions/setup-go@v5
+      - uses: actions/checkout@v5
+      - uses: actions/setup-go@v6
         with:
           go-version: "1.25"
       - name: Download dependencies
@@ -32,8 +32,8 @@ jobs:
     runs-on: ubuntu-latest
     needs: go
     steps:
-      - uses: actions/checkout@v4
-      - uses: actions/setup-node@v4
+      - uses: actions/checkout@v5
+      - uses: actions/setup-node@v5
         with:
           node-version: "20"
       - name: Install dependencies
@@ -57,11 +57,11 @@ jobs:
     runs-on: ubuntu-latest
     needs: go
     steps:
-      - uses: actions/checkout@v4
-      - uses: actions/setup-go@v5
+      - uses: actions/checkout@v5
+      - uses: actions/setup-go@v6
         with:
           go-version: "1.25"
       - name: Build coordinator
         run: go build -o aicodingagentteam ./cmd/aicodingagentteam
       - name: Dogfood quality gate
-        run: ./aicodingagentteam verify
+        run: ./aicodingagentteam verify

pkg/contracts/contracts_test.go

@@ -0,0 +1,93 @@
+package contracts
+
+import "testing"
+
+func TestCrossCheck_NoMismatches(t *testing.T) {
+	c := &Contract{
+		Paths: map[string]PathItem{
+			"/api/users": {Get: &Operation{OperationID: "listUsers", Method: "GET", Path: "/api/users"}},
+		},
+	}
+	calls := []CallSite{
+		{File: "frontend.ts", Method: "GET", Path: "/api/users", Line: 10},
+	}
+	mismatches := CrossCheck(c, calls)
+	if len(mismatches) != 0 {
+		t.Errorf("expected 0 mismatches, got %d: %v", len(mismatches), mismatches)
+	}
+}
+
+func TestCrossCheck_PathNotInContract(t *testing.T) {
+	c := &Contract{
+		Paths: map[string]PathItem{
+			"/api/users": {Get: &Operation{}},
+		},
+	}
+	calls := []CallSite{
+		{File: "app.ts", Method: "GET", Path: "/api/unknown", Line: 5},
+	}
+	mismatches := CrossCheck(c, calls)
+	if len(mismatches) != 1 {
+		t.Fatalf("expected 1 mismatch, got %d", len(mismatches))
+	}
+	if mismatches[0].Severity != "blocking" {
+		t.Errorf("expected blocking severity, got %s", mismatches[0].Severity)
+	}
+	if mismatches[0].Call.Path != "/api/unknown" {
+		t.Errorf("unexpected path: %s", mismatches[0].Call.Path)
+	}
+}
+
+func TestCrossCheck_MethodNotAllowed(t *testing.T) {
+	c := &Contract{
+		Paths: map[string]PathItem{
+			"/api/users": {Get: &Operation{OperationID: "listUsers", Method: "GET"}},
+		},
+	}
+	calls := []CallSite{
+		{File: "app.ts", Method: "DELETE", Path: "/api/users", Line: 12},
+	}
+	mismatches := CrossCheck(c, calls)
+	if len(mismatches) != 1 {
+		t.Fatalf("expected 1 mismatch, got %d", len(mismatches))
+	}
+	if mismatches[0].Severity != "blocking" {
+		t.Errorf("expected blocking, got %s", mismatches[0].Severity)
+	}
+}
+
+func TestCrossCheck_AllMethods(t *testing.T) {
+	c := &Contract{
+		Paths: map[string]PathItem{
+			"/api/r": {
+				Get:    &Operation{Method: "GET"},
+				Post:   &Operation{Method: "POST"},
+				Put:    &Operation{Method: "PUT"},
+				Delete: &Operation{Method: "DELETE"},
+				Patch:  &Operation{Method: "PATCH"},
+			},
+		},
+	}
+	for _, m := range []string{"GET", "POST", "PUT", "DELETE", "PATCH"} {
+		calls := []CallSite{{Method: m, Path: "/api/r"}}
+		if mm := CrossCheck(c, calls); len(mm) != 0 {
+			t.Errorf("method %s should be allowed, got mismatches: %v", m, mm)
+		}
+	}
+}
+
+func TestMethodExists_UnknownMethod(t *testing.T) {
+	item := PathItem{Get: &Operation{}}
+	if methodExists(item, "HEAD") {
+		t.Error("HEAD should not be recognized")
+	}
+}
+
+func TestCrossCheck_EmptyContract(t *testing.T) {
+	c := &Contract{Paths: map[string]PathItem{}}
+	calls := []CallSite{{File: "f.ts", Method: "GET", Path: "/anything"}}
+	mismatches := CrossCheck(c, calls)
+	if len(mismatches) != 1 {
+		t.Fatalf("expected 1 mismatch for empty contract, got %d", len(mismatches))
+	}
+}

pkg/runtime/runtime_test.go

@@ -0,0 +1,66 @@
+package runtime
+
+import (
+	"context"
+	"testing"
+)
+
+func TestBackendConstants(t *testing.T) {
+	backends := map[Backend]string{
+		BackendClaudeCode: "claude-code",
+		BackendCodex:      "codex",
+		BackendOpenCode:   "opencode",
+		BackendDSH:        "deepseek-dsh",
+	}
+	for b, want := range backends {
+		if string(b) != want {
+			t.Errorf("backend %q expected %q, got %q", b, want, string(b))
+		}
+	}
+}
+
+func TestEventTypes(t *testing.T) {
+	cases := []struct {
+		got  EventType
+		want string
+	}{
+		{EventStart, "start"},
+		{EventMessage, "message"},
+		{EventToolCall, "tool_call"},
+		{EventDone, "done"},
+		{EventError, "error"},
+	}
+	for _, c := range cases {
+		if string(c.got) != c.want {
+			t.Errorf("event type %q expected %q", c.got, c.want)
+		}
+	}
+}
+
+// TestRuntimeInterfaceCompiles ensures the Runtime interface is satisfiable
+// and its method signatures remain stable (compile-time check).
+type stubRuntime struct{}
+
+func (stubRuntime) StartSession(ctx context.Context, opts SessionOpts) (SessionID, error) {
+	return "", nil
+}
+func (stubRuntime) DestroySession(ctx context.Context, id SessionID) error { return nil }
+func (stubRuntime) SendTask(ctx context.Context, id SessionID, task TaskPayload) (<-chan Event, error) {
+	return nil, nil
+}
+func (stubRuntime) Capabilities() HostCapabilities                 { return HostCapabilities{} }
+func (stubRuntime) ModelInfo() ModelInfo                           { return ModelInfo{} }
+func (stubRuntime) Pause(ctx context.Context, id SessionID) error  { return nil }
+func (stubRuntime) Resume(ctx context.Context, id SessionID) error { return nil }
+func (stubRuntime) AuthStatus(ctx context.Context, id SessionID) (AuthStatus, error) {
+	return AuthStatus{}, nil
+}
+
+var _ Runtime = stubRuntime{}
+
+func TestRuntimeInterfaceImplemented(t *testing.T) {
+	var r Runtime = stubRuntime{}
+	if _, err := r.AuthStatus(context.TODO(), ""); err != nil {
+		t.Errorf("unexpected error: %v", err)
+	}
+}