message Result {
  Advice.Level status = 1;
  string title = 2;
  string content = 3;
  int32 code = 4;

  // Target identification for consolidated results
  // Format: instances/{instance}/databases/{database}
  string target = 7;
  Type type = 8;

  enum Type {
    TYPE_UNSPECIFIED = 0;
    STATEMENT_ADVISE = 1;
    STATEMENT_SUMMARY_REPORT = 2;
    GHOST_SYNC = 3;
  }

  oneof report {
    SqlSummaryReport sql_summary_report = 5;
    SqlReviewReport sql_review_report = 6;
  }
  // ... rest unchanged
}

buf format -w proto && buf lint proto && cd proto && buf generate

but commit <branch> -m "proto(v1): consolidate PlanCheckRun - move type/target to Result"

func convertToPlanCheckRuns(projectID string, planUID int64, runs []*store.PlanCheckRunMessage) []*v1pb.PlanCheckRun {
	var planCheckRuns []*v1pb.PlanCheckRun
	for _, run := range runs {
		planCheckRuns = append(planCheckRuns, &v1pb.PlanCheckRun{
			Name:       common.FormatPlanCheckRun(projectID, planUID, int64(run.UID)),
			Status:     convertToPlanCheckRunStatus(run.Status),
			Results:    convertToPlanCheckRunResults(run.Result.GetResults()),
			Error:      run.Result.Error,
			CreateTime: timestamppb.New(run.CreatedAt),
		})
	}
	return planCheckRuns
}

func convertToPlanCheckRunResult(result *storepb.PlanCheckRunResult_Result) *v1pb.PlanCheckRun_Result {
	resultV1 := &v1pb.PlanCheckRun_Result{
		Status:  convertToPlanCheckRunResultStatus(result.Status),
		Title:   result.Title,
		Content: result.Content,
		Code:    result.Code,
		Target:  result.Target,
		Type:    convertToV1ResultType(result.Type),
	}
	// ... report conversion unchanged
	return resultV1
}

func convertToV1ResultType(t storepb.PlanCheckType) v1pb.PlanCheckRun_Result_Type {
	switch t {
	case storepb.PlanCheckType_PLAN_CHECK_TYPE_STATEMENT_ADVISE:
		return v1pb.PlanCheckRun_Result_STATEMENT_ADVISE
	case storepb.PlanCheckType_PLAN_CHECK_TYPE_STATEMENT_SUMMARY_REPORT:
		return v1pb.PlanCheckRun_Result_STATEMENT_SUMMARY_REPORT
	case storepb.PlanCheckType_PLAN_CHECK_TYPE_GHOST_SYNC:
		return v1pb.PlanCheckRun_Result_GHOST_SYNC
	default:
		return v1pb.PlanCheckRun_Result_TYPE_UNSPECIFIED
	}
}

golangci-lint run --allow-parallel-runners backend/api/v1/plan_service.go

but commit <branch> -m "api: update converters for consolidated PlanCheckRun"

import {
  type PlanCheckRun,
  PlanCheckRun_Status,
  PlanCheckRun_Result_Type,
} from "@/types/proto-es/v1/plan_service_pb";

export const HiddenPlanCheckTypes = new Set<PlanCheckRun_Result_Type>([
  PlanCheckRun_Result_Type.STATEMENT_SUMMARY_REPORT,
]);

export const planCheckRunSummaryForCheckRunList = (
  planCheckRuns: PlanCheckRun[]
) => {
  const summary: PlanCheckRunSummary = {
    runningCount: 0,
    successCount: 0,
    warnCount: 0,
    errorCount: 0,
  };

  for (const checkRun of planCheckRuns) {
    // If still running, count as running
    if (checkRun.status === PlanCheckRun_Status.RUNNING) {
      summary.runningCount++;
      continue;
    }
    if (checkRun.status === PlanCheckRun_Status.FAILED) {
      summary.errorCount++;
      continue;
    }
    if (checkRun.status === PlanCheckRun_Status.CANCELED) {
      continue;
    }

    // For DONE status, analyze results by type
    // Group results by type-target to count unique checks
    const resultsByTypeTarget = new Map<string, Advice_Level>();
    for (const result of checkRun.results) {
      if (HiddenPlanCheckTypes.has(result.type)) {
        continue;
      }
      const key = `${result.type}-${result.target}`;
      const existing = resultsByTypeTarget.get(key);
      // Keep worst status
      if (!existing || result.status > existing) {
        resultsByTypeTarget.set(key, result.status);
      }
    }

    for (const status of resultsByTypeTarget.values()) {
      switch (status) {
        case Advice_Level.SUCCESS:
          summary.successCount++;
          break;
        case Advice_Level.WARNING:
          summary.warnCount++;
          break;
        case Advice_Level.ERROR:
          summary.errorCount++;
          break;
      }
    }
  }

  return summary;
};

export const planCheckRunListForSpec = (
  planCheckRuns: PlanCheckRun[],
  spec: Plan_Spec
): PlanCheckRun[] => {
  const targets = flattenTargetsOfSpec(spec);

  // With consolidated model, filter runs that have results matching our targets
  return planCheckRuns.filter((run) => {
    return run.results.some((result) => targets.includes(result.target));
  });
};

export const planCheckRunListForTask = (issue: ComposedIssue, task: Task) => {
  const target = databaseForTask(projectOfIssue(issue), task).name;

  // With consolidated model, return runs that have results for this target
  return issue.planCheckRunList.filter((run) => {
    return run.results.some((result) => result.target === target);
  });
};

export const planCheckRunSummaryForIssue = (issue: ComposedIssue) => {
  // With consolidated model, just use all plan check runs
  return planCheckRunSummaryForCheckRunList(issue.planCheckRunList);
};

const groupedByType = computed(() => {
  const typeMap = new Map<PlanCheckRun_Result_Type, {
    type: PlanCheckRun_Result_Type;
    results: PlanCheckRun_Result[];
    status: PlanCheckRun_Status;
  }>();

  for (const run of props.planCheckRunList) {
    for (const result of run.results) {
      if (!typeMap.has(result.type)) {
        typeMap.set(result.type, {
          type: result.type,
          results: [],
          status: run.status,
        });
      }
      typeMap.get(result.type)!.results.push(result);
    }
  }

  return orderBy(
    Array.from(typeMap.values()),
    [(g) => PlanCheckTypeOrderDict.get(g.type) ?? 99999],
    ["asc"]
  );
});

go build -ldflags "-w -s" -p=16 -o ./bytebase-build/bytebase ./backend/bin/server/main.go

golangci-lint run --allow-parallel-runners

pnpm --dir frontend type-check

pnpm --dir frontend biome:check